<?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="1999566976857398962">"Da"</string>
    <string name="no" msgid="5541738710521607130">"Ne"</string>
    <string name="create" msgid="986997212165228751">"Kreiraj"</string>
    <string name="allow" msgid="3763244945363657722">"Dozvoli"</string>
    <string name="deny" msgid="7326117222944479942">"Odbij"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Uključi"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Nepoznato"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="1646187747875476269">
      <item quantity="one">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> korak vas dijeli od toga da postanete programer.</item>
      <item quantity="few">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka vas dijele od toga da postanete programer.</item>
      <item quantity="other">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka vas dijeli od toga da postanete programer.</item>
    </plurals>
    <string name="show_dev_on" msgid="2840850085134853754">"Postali ste programer!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nema potrebe, već ste programer."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Prvo omogućite opcije za programere."</string>
    <string name="header_category_wireless_networks" msgid="303445626075235229">"Bežična veza i mreže"</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Aktivan"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ne radi"</string>
    <string name="radioInfo_service_emergency" msgid="6838935881091760942">"Samo pozivi za hitne slučajeve"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio je isključen"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Nije u romingu"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Isključena"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Povezivanje"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Povezano"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Obustavljeno"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Nepoznato"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="1816306320988638382">"Deaktiviraj USB pohranu"</string>
    <string name="sdcard_unmount" product="default" msgid="8078570285871053815">"Deaktiviraj SD karticu"</string>
    <string name="sdcard_format" product="nosdcard" msgid="3248760426252305366">"Izbriši USB pohranu"</string>
    <string name="sdcard_format" product="default" msgid="3676635435136326182">"Izbriši SD karticu"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Pregled"</string>
    <string name="preview_page_indicator_content_description" msgid="2790254666634885865">"Pregled, strana <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1296835853522566260">"Smanjite ili povećajte tekst na ekranu."</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Napravi manji"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Napravi veći"</string>
    <string name="font_size_preview_text_headline" msgid="1173103737980511652">"Uzorak teksta"</string>
    <string name="font_size_preview_text_title" msgid="6363561029914452382">"Čarobnjak iz Oza"</string>
    <string name="font_size_preview_text_subtitle" msgid="5806349524325544614">"Poglavlje 11: Smaragdni grad Oz"</string>
    <string name="font_size_preview_text_body" msgid="3323732544011097199">"I pored toga što su im oči bile zaštićene zelenim naočalama, Dorothy i njeni prijatelji su isprva bili zaslijepljeni blještavilom tog grada. Ulicama su se nizale predivne zelene kuće izgrađene od zelenog mermera i obasute svjetlucavim smaragdima. Hodali su trotoarom od istog zelenog mermera, a na spoju između blokova nalazili su se usko postavljeni redovi smaragda koji su svjetlucali od sunčevog sjaja. Prozorska okna su bila od zelenog stakla. Čak je i nebo iznad grada imalo zeleni odsjaj, baš kao i sunčeve zrake. \n\nTu je bilo mnogo ljudi, muškaraca, žena i djece, šetali su odjeveni u zelenu odjeću i imali su zelenkastu kožu. S čuđenjem su gledali u Dodorthy i njenu čudnovatu družinu. Kada su vidjeli lava, sva djeca su pobjegla i sakrila se iza svoje majke; ali niko im se nije obraćao. Na ulici je bilo mnogo prodavnica, a Dorothy je vidjela da je u njima sve zeleno. U ponudi su bili zeleni slatkiši i zelene kokice, kao i zelene cipele, zeleni šeširi i raznorazna zelena odjeća. Na jednom mjestu čovjek je prodavao zelenu limunadu, a kada su je djeca kupovala, Dorothy je vidjela da plaćaju zelenim novčićima. \n\nKoliko se dalo primijetiti, tamo nije bilo konja ni bilo kojih drugih životinja, a muškarci su raznosili stvari pomoću zelenih kolica koja su gurali pred sobom. Svi su djelovali sretno, zadovoljno i uspješno."</string>
    <string name="font_size_save" msgid="206892409190870726">"Uredu"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="6071836464978826249">"USB pohrana"</string>
    <string name="sdcard_setting" product="default" msgid="3713462184783824923">"SD kartica"</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Vidljiv za sve obližnje Bluetooth uređaje (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Vidljiv za sve obližnje Bluetooth uređaje"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nije vidljiv za druge Bluetooth uređaje"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Vidljiv samo za uparene uređaje"</string>
    <string name="bluetooth_visibility_timeout" msgid="7611781967900196353">"Istek vremena za vidljivost"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="7405038248936935186">"Zaključaj glasovno biranje"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4959591522483403402">"Spriječi korištenje bluetooth birača kada je ekran zaključan"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth uređaji"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Naziv uređaja"</string>
    <string name="bluetooth_device_details" msgid="630702184344217832">"Postavke uređaja"</string>
    <string name="bluetooth_profile_details" msgid="1269419918127093325">"Postavke profila"</string>
    <string name="bluetooth_name_not_set" msgid="4654357917928126208">"Nije postavljeno ime, koristi se ime računa"</string>
    <string name="bluetooth_scan_for_devices" msgid="8143654526358934069">"Potraži uređaje"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Promijenite naziv uređaja"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Promijeni naziv"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Želite li prekinuti vezu s uređajem?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="1934297101665686854">"Vaš telefon će prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="336622948210457991">"Vaš tablet će prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="6944790936166852428">"Vaš uređaj će prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="4173740094381092185">"Prekini vezu"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="909734990821975673">"Nemate odobrenje da mijenjate postavke za Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Uparivanje novog uređaja"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_is_visible_message" msgid="3811631869768157387">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je vidljiv uređajima u blizini, dok su postavke Bluetootha otvorene."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="4782330594323261630">"Bluetooth adresa telefona: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="1257226691967432025">"Bluetooth adresa tableta: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="2863536947810007600">"Bluetooth adresa uređaja: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="777406775955421784">"Želite li prekinuti vezu sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="6379176741690311973">"Emitovanje"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Neimenovani Bluetooth uređaj"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Pretraživanje"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Nema Bluetooth uređaja u blizini."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Zahtjev za uparivanje putem Bluetootha"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Zahtjev za uparivanje"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Dodirnite za spajanje s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="685424727760622632">"Primljeni fajlovi"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="7097860463458492953">"Fajlovi primljeni putem Bluetootha"</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth je isključen"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Dodirnite da ga uključite"</string>
    <string name="device_picker" msgid="2427027896389445414">"Odaberi Bluetooth uređaj"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Aplikacija želi uključiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Aplikacija želi isključiti Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="1273405567801929487">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš tablet bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="7013223328571883275">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš telefon bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="3266007454914144057">"Aplikacija želi da vaš tablet bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="7989444746980501116">"Aplikacija želi da vaš telefon bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="6482084870735107773">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš tablet bude vidljiv drugim Bluetooth uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="2352494279465502950">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš telefon bude vidljiv drugim Bluetooth uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="2732992604509910896">"Aplikacija želi da vaš tablet bude vidljiv drugim Bluetooth uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="356982103612920264">"Aplikacija želi da vaš telefon bude vidljiv drugim Bluetooth uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="6103655179509599427">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth te učiniti vaš tablet vidljivim drugim uređajima <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="934276632311449337">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth te učiniti vaš telefon vidljivim drugim uređajima <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="1284048348024444485">"Aplikacija želi uključiti Bluetooth te učiniti vaš tablet vidljivim drugim uređajima <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="2661614145022629454">"Aplikacija želi uključiti Bluetooth te učiniti vaš telefon vidljivim drugim uređajima <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="8588317955400593623">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth i učiniti vaš tablet vidljivim drugim uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="4047444317445386579">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth i učiniti vaš telefon vidljivim drugim uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="4922952478824372605">"Aplikacija želi uključiti Bluetooth i učiniti vaš tablet vidljivim drugim uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="1381582950049639439">"Aplikacija želi uključiti Bluetooth i učiniti vaš telefon vidljivim drugim uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Uključivanje funkcije Bluetooth…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Isključivanje funkcije Bluetooth…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Zahtjev za uspostavljanje Bluetooth veze"</string>
    <string name="bluetooth_connection_notif_message" msgid="6087344980352898209">"Dodirnite za povezivanje s uređajem \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="2537152772549874391">"Da li se želite povezati na \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"?"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Zahtjev za pristup imeniku"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="7153531868579789993">"Uređaj <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti vašim kontaktima i historiji poziva. Želite li odobriti pristup uređaju <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>?"</string>
    <string name="bluetooth_remember_choice" msgid="173821849670438110">"Ne pitaj ponovo"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2080511174185036562">"Ne pitaj ponovo"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Zahtjev za pristup porukama"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="2647611490952377156">"%1$s želi pristupiti svojim porukama. Dozvoliti pristup za %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="473439406287008397">"Zahtjev za pristup SIM-u"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="2849083276356078655">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti vašoj SIM kartici. Odobrenje pristupa SIM kartici će onemogućiti vezu za prijenos podataka na vašem uređaju za vrijeme trajanja veze. Odobri pristup uređaju <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Uređaj je vidljiv drugim uređajima kao \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\""</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Uključite Bluetooth za povezivanje s drugim uređajima."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vaši uređaji"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Uparivanje novog uređaja"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3506962706611366830">"Omogućite tabletu da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2192027516577675587">"Omogućite uređaju da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="768958961865499804">"Omogućite telefonu da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Onemogući rasterećenje Bluetootha A2DP"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="8610420176339657720">"Ponovo pokrenuti?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8333029144800835996">"Da promijenite ovu postavku, treba ponovo pokrenuti uređaj."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="3488695418187553566">"Pokreni opet"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="4930826928585464191">"Otkaži"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Uređaji za medije"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Uređaji za pozive"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Drugi uređaji"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Sačuvani uređaji"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth će se uključiti za uparivanje"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Postavke veze"</string>
    <string name="connected_device_previously_connected_title" msgid="605808252622814415">"Prethodno povezani uređaji"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Prethodno povezani"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth je uključen"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Prikaži sve"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum i vrijeme"</string>
    <string name="choose_timezone" msgid="1450780665958642147">"Odaberite vremensku zonu"</string>
    <!-- no translation found for intent_sender_data_label (1733806423295725392) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="3202857258557610646">"Pošalji <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="257853357827275530">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="519934560779343541">"Pokreni <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="5087385727740280207">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="36614006839665458">"Račun:"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proksi server"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Obriši"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Priključak za proksi"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Zaobilazni proksi za"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Vrati na zadano"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Gotovo"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Hostname za proksi"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Pažnja"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Uredu"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Uneseni naziv host računara nije važeći."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Unesena lista isključenja nije odgovarajuće formatirana. Unesite listu isključenih domena u obliku liste stavki odvojenih zarezom."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Morate popuniti adresno polje"</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Adresno polje mora biti prazno ako je server polje prazno."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Uneseni port nije važeći."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Preglednik koristi HTTP proksi, ali ga druge aplikacije ne mogu koristiti."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL za PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Pinguj ime računara (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="8327436534663560713">"Pinguj ime računara (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test HTTP klijenta:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Pokreni ping test"</string>
    <string name="sdcard_changes_instructions" msgid="2331969501845866957">"Promjene stupaju na snagu kada se ponovo poveže USB kabl."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="129059989000252994">"Omogući USB masovnu pohranu"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="5298511430610207103">"Ukupno bajtova:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="6189761476582690998">"USB pohrana nije aktivirana."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="6601962586941623203">"Nema SD kartice."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="7721283102767669004">"Dostupno bajtova:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="4878190674458263222">"USB pohrana se koristi kao uređaj za masovnu pohranu."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="8850227049504860012">"SD kartica se koristi kao uređaj za masovnu pohranu."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="1053258530368541571">"Sigurno je izbaciti USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="5813940671700138561">"Sada je sigurno ukloniti SD karticu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="209564009449909311">"USB pohr. ukl. dok se korist.!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="6817342973919819392">"SD kartica je uklonjena dok je još bila u upotrebi!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="5646588579332741943">"Iskorišteno bajtova:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="8037280964384235345">"Skenir. medija na USB pohrani…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="3297316465982471437">"Skeniranje medijskih sadržaja na SD kartici…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3444648373391629840">"USB pohr. je akt. samo za čit."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4338796260718910164">"SD kartica je aktivirana samo za čitanje."</string>
    <string name="skip_label" msgid="6380034601349015895">"Preskoči"</string>
    <string name="next_label" msgid="1248293387735652187">"Naprijed"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Jezici"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Ukloni"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Dodajte jezik"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="2845515796732609837">
      <item quantity="one">Ukloniti odabrane jezike?</item>
      <item quantity="few">Ukloniti odabrane jezike?</item>
      <item quantity="other">Ukloniti odabrane jezike?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekst će biti prikazan na drugom jeziku"</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Ne mogu se ukloniti svi jezici"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Zadržite najmanje jedan preferirani jezik"</string>
    <string name="locale_not_translated" msgid="5079729745235316146">"Možda nije dostupno u nekim aplikacijama"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Pomjeri nagore"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Pomjeri nadolje"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Pomjeri na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Pomjeri na dno"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Ukloni jezik"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Odaberite aktivnost"</string>
    <string name="display_label" msgid="3056320781191343221">"Ekran"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="1850505156136467106">"USB pohrana"</string>
    <string name="sd_card_settings_label" product="default" msgid="8715502912796241588">"SD kartica"</string>
    <string name="proxy_settings_label" msgid="6300573815025557843">"Postavke proksija"</string>
    <string name="cancel" msgid="5780102414089664898">"Otkaži"</string>
    <string name="okay" msgid="4827099303045669054">"Uredu"</string>
    <string name="forget" msgid="3754013654135912783">"Zaboravi"</string>
    <string name="save" msgid="3125033126936493822">"Sačuvaj"</string>
    <string name="done" msgid="7497982645646431310">"Gotovo"</string>
    <string name="apply" msgid="7834684883190163536">"Primijeni"</string>
    <string name="share" msgid="8502235338607613795">"Dijeli"</string>
    <string name="add" msgid="8335206931421683426">"Dodaj"</string>
    <string name="settings_label" msgid="943294133671632976">"Postavke"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Postavke"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Prečica za postavke"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Način rada u avionu"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bežična veza i mreže"</string>
    <string name="radio_controls_summary" msgid="9028430178697624501">"Upravljanje WiFi mrežom, Bluetoothom, načinom rada u avionu, mobilnim i VPN mrežama"</string>
    <string name="cellular_data_summary" msgid="6551434804367912367">"Dopusti prijenos podataka mobilnom mrežom"</string>
    <string name="allow_data_usage_title" msgid="2645963379925196671">"Dozvoli prijenos podataka u romingu"</string>
    <string name="roaming" msgid="3055365654530847985">"Roming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Povezivanje na usluge prijenosa podataka u romingu"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Povezivanje na usluge prijenosa podataka u romingu"</string>
    <string name="roaming_reenable_message" msgid="5150423860521673540">"Ostali ste bez veze za prijenos podataka jer ste napustili matičnu mrežu dok je roming podataka isključen."</string>
    <string name="roaming_turn_it_on_button" msgid="6999283810847157816">"Uključi"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Mogu nastati troškovi rominga."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="5629953315019604726">"Kada dozvolite prijenos podataka u romingu, mogući su troškovi za roaming.\n\nOva postavka utiče na sve korisnike ovog tableta."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="3693719745119874126">"Kada dozvolite prijenos podataka u romingu, mogući su troškovi za roaming.\n\nOva postavka utiče na sve korisnike ovog telefona."</string>
    <string name="roaming_reenable_title" msgid="770824950144026180">"Dozvoliti roming podataka?"</string>
    <string name="networks" msgid="5184501333492775095">"Izbor operatera"</string>
    <string name="sum_carrier_select" msgid="1669911795517995916">"Odaberite operatera"</string>
    <string name="date_and_time_settings_title" msgid="2305454529709812364">"Datum i vrijeme"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="1841717199409629742">"Postavljanje datuma i vremena"</string>
    <string name="date_and_time_settings_summary" msgid="334967758944498010">"Postavljanje datuma, vremena, vremenske zone i formata"</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Postavi vrijeme automatski"</string>
    <string name="zone_auto_title" msgid="3993580453604839924">"Automatski postavi vremensku zonu"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Koristi lokalni zadani format"</string>
    <string name="date_time_24hour_title" msgid="1445056824481243600">"24-satni format"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Koristi 24-satni format"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Vrijeme"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Format vremena"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Vremenska zona"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Odabir vremenske zone"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Pretražite regiju"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Regija"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Odaberite odstupanje od UTC-a"</string>
    <string name="zone_change_to_from_dst" msgid="686451769985774294">"<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="2186042522225153092">"<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="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="7004693956837388129">"Koristi <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> počinje dana: <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>"</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Koristi <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Ne koristi ljetno računanje vremena."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Ljetno računanje vremena"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardno vrijeme"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Odabir prema regiji"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Odabir prema odstup. od UTC-a"</string>
    <string name="date_picker_title" msgid="646573308567782578">"Datum"</string>
    <string name="time_picker_title" msgid="1784236407401743393">"Vrijeme"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Zaključaj nakon isteka vremena ekrana"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon isteka vremena"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Odmah nakon isteka vremena, 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="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon isteka vremena, osim kada ga <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> drži otključanim"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="197365342192696406">"Prikaži informacije o vlasniku na zaključanom ekranu"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Dodav. teksta na zaklj. ekranu"</string>
    <string name="security_enable_widgets_title" msgid="676199714313423099">"Omogući vidžete"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="5191637768484254146">"Onemogućio administrator"</string>
    <string name="lockdown_settings_title" msgid="8988970335658365075">"Prikaži opciju zaključavanja"</string>
    <string name="lockdown_settings_summary" msgid="7422522013953398806">"Prikaži opciju dugmeta za uključivanje koja isključuje Smart Lock, biometrijsko otključavanje i obavještenja na zaključanom ekranu."</string>
    <string name="trust_lost_locks_screen_title" msgid="4231232144565291276">"Zaključan ekran kad nema pouzdanosti"</string>
    <string name="trust_lost_locks_screen_summary" msgid="718374221849537361">"Ako je omogućeno, uređaj će se zaključati kad zadnji pouzdani agent više ne bude pouzdan"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ništa"</string>
    <string name="owner_info_settings_status" msgid="7488764871758677862">"<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="841926875876050274">"Npr. Edinov Android."</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="5734739022887933365">"Prikazuj informacije o profilu na zaključ. ekranu"</string>
    <string name="Accounts_settings_title" msgid="8434263183710375412">"Računi"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Lokacija"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Koristi lokaciju"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Isključeno"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="1019959038518185676">
      <item quantity="one">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacija ima pristup lokaciji</item>
      <item quantity="few">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacije imaju pristup lokaciji</item>
      <item quantity="other">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacija ima pristup lokaciji</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Učitavanje…"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Računi"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sigurnost"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifriranje i akreditivi"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="5298195959570992363">"Telefon je šifriran"</string>
    <string name="decryption_settings_summary" product="default" msgid="1742645256103613503">"Telefon nije šifriran"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="3776741531205406800">"Uređaj je šifriran"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="1864963068216544631">"Uređaj nije šifriran"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Zaključani ekran"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Šta prikazati"</string>
    <string name="security_settings_summary" msgid="1627059516127354233">"Postavite Moju lokaciju, otključavanje ekrana, zaključavanje SIM kartice, zaključavanje pohrane akreditiva"</string>
    <string name="cdma_security_settings_summary" msgid="2455517905101186330">"Postavite Moju lokaciju, otključavanje ekrana, zaključavanje pohrane akreditiva"</string>
    <string name="security_passwords_title" msgid="4154420930973818581">"Privatnost"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nije dostupno"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Sigurnosni status"</string>
    <string name="security_dashboard_summary_face" msgid="4198949293847206382">"Zaključavanje ekrana, otključavanje licem"</string>
    <string name="security_dashboard_summary" msgid="8750183806533140464">"Zaključavanje ekrana, otisak prsta"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="1044589595710115123">"Zaključavanje ekrana"</string>
    <string name="multi_biometric_enroll_title" msgid="3007607723604088374">"Sigurno otključajte telefon licem i otiskom prsta"</string>
    <string name="multi_biometric_enroll_subtitle" msgid="8357072842904027301">"Možete se prijaviti i u aplikacije i potvrditi plaćanja"</string>
    <string name="multi_biometric_enroll_setup_with" msgid="421375792889910150">"Postavite otključavanje koristeći:"</string>
    <string name="multi_biometric_enroll_face_unlock_title" msgid="7627564065626355692">"Otključavanje licem"</string>
    <string name="multi_biometric_enroll_face_unlock_description" msgid="7626442550602926682">"Pojednostavite otključavanje telefona"</string>
    <string name="multi_biometric_enroll_fingerprint_unlock_title" msgid="3839935495273854171">"Otisak prsta"</string>
    <string name="multi_biometric_enroll_fingerprint_unlock_description" msgid="116938134430420778">"Otključajte telefon dok vam je u džepu"</string>
    <string name="multi_biometric_enroll_skip" msgid="7301215196571580858">"Preskoči"</string>
    <string name="multi_biometric_enroll_next" msgid="6220680618102151619">"Naprijed"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Lice je dodano"</string>
    <string name="security_settings_face_preference_summary_none" msgid="3758209126322559995">"Postavite otključavanje licem"</string>
    <string name="security_settings_face_preference_title" msgid="821557938243856757">"Otključavanje licem"</string>
    <string name="security_settings_face_profile_preference_title" msgid="4618796080378248740">"Otključavanje licem za radni profil"</string>
    <string name="security_settings_face_enroll_education_title" msgid="8662585502032112675">"Kako postaviti otključavanje licem"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4632402390714441918">"Postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Koristite lice za autentifikaciju"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Započni"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="4681495507974718824">"Ako je otključavanje licem za pristupačnost isključeno, neki koraci za postavljanje možda neće funkcionirati ispravno s Talkbackom."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Nazad"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Nastavi postavljanje"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Koristi postavku za pristupačnost"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="6763509014732769185"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Otkaži"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Ne, hvala"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="1822303197642630076">"Prihvatam"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Više"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Otključajte pomoću lica"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Koristite lice za autentifikaciju"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="3015751486939484934">"Koristite lice za otključavanje telefona, odobravanje kupovine ili prijavu u aplikacije."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Koristite lice za otključavanje telefona ili odobravanje kupovina.\n\nNapomena: ne možete koristiti lice za otključavanje ovog uređaja. Za više informacija obratite se administratoru svoje organizacije."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Koristite lice za otključavanje telefona, odobravanje kupovine ili prijavu u aplikacije."</string>
    <string name="security_settings_face_enroll_introduction_footer_part_0" msgid="908831787971630413"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="4438129587730915782"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="6099785970191751036"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="8708726599723727710"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Namjestite lice u centar kruga"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Preskoči"</string>
    <string name="face_add_max" msgid="4578405795494514876">"Možete dodati najviše <xliff:g id="COUNT">%d</xliff:g> lica"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Dodali ste maksimalan broj lica"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Nije moguće dodati više lica"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registracija nije dovršena"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Uredu"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Vrijeme za snimanje lica je isteklo. Pokušajte ponovo."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Upis lica nije uspio."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Sve je spremno. Izgleda dobro."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Gotovo"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="9080635904939148410">"Poboljšajte performanse otključavanja licem"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="2318506792574194633">"Ponovo postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="8907917317111783249">"Ponovo postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Poboljšajte sigurnost i performanse"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="7124713074067550039">"Postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="950213874209080175">"Izbrišite trenutne podatke o licu da ponovo postavite otključavanje licem.\n\nPodaci o licu koje je koristila funkcija otključavanja licem će se trajno i sigurno izbrisati. Nakon uklanjanja, trebat će vam PIN, uzorak ili lozinka za otključavanje telefona, prijavu u aplikacije i potvrdu plaćanja."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="2374998717426341095">"Koristi otključavanje licem za"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="5209963876503148501">"Otključavanje telefona"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="8813038341122613020">"Prijava u aplikaciju i plaćanja"</string>
    <string name="security_settings_face_settings_require_category" msgid="3906382658164073665">"Uslovi za otključavanje licem"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Traži da oči budu otvorene"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Da otključate telefon, oči vam moraju biti otvorene"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Uvijek traži potvrdu"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6454776517804994007">"Kod otključavanja licem za aplikacije, uvijek tražite potvrdu"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="6491161841504747384">"Izbriši podatke o licu"</string>
    <string name="security_settings_face_settings_enroll" msgid="4656842124181309056">"Postavite otključavanje licem"</string>
    <string name="security_settings_face_settings_top_intro" msgid="4199311264578653665">"Koristite otključavanje licem za otključavanje uređaja, prijavu u aplikacije i potvrdu plaćanja."</string>
    <string name="security_settings_face_settings_footer" msgid="4378074697208244539">"Imajte na umu:\nTelefon možete otključati ako pogledate u njega, čak i kada vam to nije namjera.\n\nVaš telefon može otključati i neko drugi ako ga prinese vašem licu.\n\nVaš telefon može otključati osoba koja mnogo liči na vas, kao što je identični blizanac."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="5051230351151761265">"Imajte na umu:\nTelefon možete otključati ako pogledate u njega, čak i kada vam to nije namjera.\n\nVaš telefon može otključati i neko drugi ako ga prinese vašem licu, čak i dok su vam oči zatvorene.\n\nVaš telefon može otključati osoba koja mnogo liči na vas, kao što je identični blizanac."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2596803378375165362">"Izbrisati podatke o licu?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="3458998128212675289">"Podaci o licu koje je koristila funkcija otključavanja licem će se trajno i sigurno izbrisati. Nakon uklanjanja, trebat će vam PIN, uzorak ili lozinka za otključavanje telefona, prijavu u aplikacije i potvrdu plaćanja."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="9197485417007952865">"Otključajte telefon pomoću funkcije Otključavanje licem"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Otisak prsta"</string>
    <string name="fingerprint_manage_category_title" msgid="1249349505688268850">"Upravljanje otiscima prstiju"</string>
    <string name="fingerprint_usage_category_title" msgid="8757959085075024856">"Koristi otisak prsta za"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Dodaj otisak prsta"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5451094461919440992">"zaključavanje ekrana"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="988602245530967106">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> otisak prsta je postavljen</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> otiska prsta su postavljena</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> otisaka prstiju je postavljeno</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="521797365974277693">"Otključavanje otiskom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Koristite otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="1467469714658873533">"Samo dodirnite senzor za otisak prsta da otključate telefon, odobrite kupovinu ili da se prijavite u aplikacije. Pazite čije otiske prsta dodajete. Samo jedan dodani otisak može izvršiti sve navedeno."</string>
    <string name="security_settings_fingerprint_enroll_introduction_bottom_message" msgid="6527850754691662946">"Otisak prsta može biti manje siguran od jakog uzorka ili PIN-a."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Pomoću otiska prsta otključavajte telefon ili odobravajte kupovinu.\n\nNapomena: otisak prsta ne možete koristiti za otključavanje ovog uređaja. Za više informacija, obratite se administratoru svoje organizacije"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="5979556434735281585">"Pomoću otiska prsta otključavajte telefon ili odobravajte kupovinu.\n\nNapomena: otisak prsta može biti manje siguran od jakog uzorka ili PIN-a."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Ne, hvala"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="5683573189775460816">"Nastavi"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="370010932190960403">"Preskoči"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="7155412679784724630">"Naprijed"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Preskočiti otisak prsta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Postavljanje otiska prsta traje svega minutu ili dvije. Ako ovo preskočite, otisak prsta možete dodati kasnije u postavkama."</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Preskočiti zaključani ekran?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1570832293693405757">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj tablet ako ga izgubite, ako vam ga ukradu ili ga vratite na početne postavke."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4618501606519351904">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj uređaj ako ga izgubite, ako vam ga ukradu ili ga vratite na početne postavke."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2412426429887900241">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj telefon ako ga izgubite, ako vam ga ukradu ili ga vratite na početne postavke."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="7119039592587429936">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj tablet ako ga izgubite ili ga neko ukrade."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="3365990364131398523">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj uređaj ako ga izgubite ili ga neko ukrade."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="4908278819257287536">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj telefon ako ga izgubite ili ga neko ukrade."</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Ipak preskoči"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Nazad"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Preskoči"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dodirnite senzor"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Nalazi se na poleđini telefona. Koristite kažiprst."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="1181700918690345832">"Nalazi se na ekranu. Potražite otisak prsta sa sjajnim krugom."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustracija sa uređajem i lokacijom senzora za otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Naziv"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Uredu"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Izbriši"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Dodirnite senzor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Stavite prst na senzor i podignite ga kad osjetite vibraciju"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Podignite i ponovo dodirnite"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Nastavite podizati prst da dodate različite dijelove otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Dodan je otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8220458039597261933">"Kada vidite ovu ikonu, koristite otisak prsta za identifikaciju ili odobravanje kupovine."</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Uradit ću to kasnije"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Preskočiti postavljanje otiska prsta?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Odabrali ste da koristite otisak prsta kao jedan od načina za otključavanja telefona. Ukoliko sada preskočite ovaj korak, morat ćete ga postaviti kasnije. Postavka traje otprilike samo jednu minutu."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="6901147203720764421">"Zaštitite tablet zaključavanjem ekrana da ga niko ne može koristiti ako ga izgubite ili ga neko ukrade. Zaključavanje ekrana vam je potrebno i za postavljanje otiska prsta. Dodirnite Otkaži, a zatim postavite PIN, uzorak ili lozinku."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="1286244133923093528">"Zaštitite uređaj zaključavanjem ekrana da ga niko ne može koristiti ako ga izgubite ili ga neko ukrade. Zaključavanje ekrana vam je potrebno i za postavljanje otiska prsta. Dodirnite Otkaži, a zatim postavite PIN, uzorak ili lozinku."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="4810191157587317521">"Zaštitite telefon zaključavanjem ekrana da ga niko ne može koristiti ako ga izgubite ili ga neko ukrade. Zaključavanje ekrana vam je potrebno i za postavljanje otiska prsta. Dodirnite Otkaži, a zatim postavite PIN, uzorak ili lozinku."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="7387535629289108475">"Kada zaštitite tablet opcijom zaključavanja ekrana, niko ga neće moći koristiti u slučaju da ga izgubite ili ga neko ukrade. Zaključavanje ekrana vam je potrebno i za postavljanje otključavanja licem. Da se vratite, dodirnite Otkaži."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="4995287019957131123">"Kada zaštitite uređaj opcijom zaključavanja ekrana, niko ga neće moći koristiti u slučaju da ga izgubite ili ga neko ukrade. Zaključavanje ekrana vam je potrebno i za postavljanje otključavanja licem. Da se vratite, dodirnite Otkaži."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="7086796722966738156">"Kada zaštitite telefon opcijom zaključavanja ekrana, niko ga neće moći koristiti u slučaju da ga izgubite ili ga neko ukrade. Zaključavanje ekrana vam je potrebno i da postavite otključavanja licem. Da se vratite, dodirnite Otkaži."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="tablet" msgid="3943278149639587227">"Kada zaštitite tablet opcijom zaključavanja ekrana, niko ga neće moći koristiti u slučaju da ga izgubite ili ga neko ukrade. Opcija zaključavanja ekrana vam treba i da postavite biometriju. Da se vratite, dodirnite Otkaži."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="device" msgid="5424064454068220988">"Kada zaštitite uređaj opcijom zaključavanja ekrana, niko ga neće moći koristiti u slučaju da ga izgubite ili ga neko ukrade. Opcija zaključavanja ekrana vam treba i da postavite biometriju. Da se vratite, dodirnite Otkaži."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="default" msgid="5668256546179188638">"Kada zaštitite telefon opcijom zaključavanja ekrana, niko ga neće moći koristiti u slučaju da ga izgubite ili ga neko ukrade. Opcija zaključavanja ekrana vam treba i da postavite biometriju. Da se vratite, dodirnite Otkaži."</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Preskočiti postavljanje PIN-a?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Preskočiti postavljanje lozinke?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Preskočiti postavljanje uzorka?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Postavi zaključavanje ekrana"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Gotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ups, to nije senzor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Dodirnite senzor na poleđini telefona. Koristite kažiprst."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="132085362209418770">"Registracija nije dovršena"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="5479647886550695766">"Vrijeme za uzimanje otiska prsta je isteklo. Pokušajte ponovo."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"Registracija otiska prsta nije uspjela. Pokušajte ponovo ili koristite drugi prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Dodaj još jedan"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Naprijed"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="7875826823637114097">"Osim otključavanja telefona, otisak prsta takođe možete koristiti za odobravanje kupovine i pristup aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="4260983700868889294">" Opcija zaključavanja ekrana je onemogućena. Da saznate više, obratite se administratoru organizacije. "<annotation id="admin_details">"Više informacija"</annotation>\n\n"I dalje možete koristiti otisak prsta za odobravanje kupovine i pristup aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Podignite prst, zatim ponovo dodirnite senzor"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Možete dodati do <xliff:g id="COUNT">%d</xliff:g> otisaka prstiju"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste maksimalan broj otisaka prstiju"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nije moguće dodati još otisaka prstiju"</string>
    <string name="fingerprint_last_delete_title" msgid="4081475675646514726">"Ukloniti sve otiske prstiju?"</string>
    <string name="fingerprint_delete_title" msgid="1469865327307917858">"Ukloni \'<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\'"</string>
    <string name="fingerprint_delete_message" msgid="1454995433333496541">"Želite li izbrisati ovaj otisak prsta?"</string>
    <string name="fingerprint_last_delete_message" msgid="93311579320049852">"Otiske prstiju nećete moći koristiti za otključavanje telefona, odobravanje kupovine ili prijavljivanje u aplikacije"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="3460246522493987163">"Otiske prstiju nećete moći koristiti za otključavanje radnog profila, odobravanje kupovine ili prijavljivanje u radne aplikacije"</string>
    <string name="fingerprint_last_delete_confirm" msgid="3294910995598819259">"Da, ukloni"</string>
    <string name="crypt_keeper_settings_title" msgid="4938812137822100044">"Šifriranje"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="7484150746479958376">"Šifriraj tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="8302873664348463041">"Šifriranje telefona"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="3866488451639592071">"Šifrirano"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="4103951371711323192">"Možete šifrirati svoje račune, postavke, preuzete aplikacije i njihove podatke, medijske podatke i druge fajlove. Nakon šifriranja tableta, uz pretpostavku da ste postavili zaključavanje ekrana (tj. postavili uzorak, numerički PIN ili lozinku), bit će potrebno da otključate ekran prilikom svakog uključivanja kako biste izvršili dešifriranje. Jedina alternativa dešifriranju je ponovno postavljanje na fabričke postavke uz brisanje svih vaših podataka.\n\nZa šifriranje je potreban jedan sat ili duže. Morate započeti sa napunjenom baterijom, a tablet treba biti priključen na napajanje tokom cijelog postupka. U slučaju prekida, izgubit ćete jedan dio ili sve svoje podatke"</string>
    <string name="crypt_keeper_desc" product="default" msgid="6180866043921135548">"Možete šifrirati svoje račune, postavke, preuzete aplikacije i njihove podatke, medijske sadržaje i druge fajlove. Nakon šifriranja telefona, uz pretpostavku da ste postavili zaključavanje ekrana (tj. postavili uzorak, numerički PIN ili lozinku), bit će potrebno da otključate ekran prilikom svakog uključivanja kako biste izvršili dešifriranje. Jedina alternativa dešifriranju je ponovno postavljanje na fabričke postavke uz brisanje svih vaših podataka.\n\nZa šifriranje je potreban jedan sat ili duže. Morate započeti sa napunjenom baterijom, a telefon treba biti priključen na napajanje tokom cijelog postupka. U slučaju prekida, izgubit ćete jedan dio ili sve svoje podatke."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="5551608011810921471">"Šifriraj tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="6370330929679426136">"Šifriraj telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="4920087247177024521">"Napunite bateriju i pokušajte ponovo."</string>
    <string name="crypt_keeper_unplugged_text" msgid="2709721134148651329">"Priključite punjač i pokušajte ponovo."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="1847280235529858357">"Nema PIN-a ili lozinke za zaključavanje ekrana"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="7210616262954236042">"Trebate postaviti PIN za zaključavanje ekrana ili lozinku da biste mogli pokrenuti šifriranje."</string>
    <string name="crypt_keeper_confirm_title" msgid="8600000209722452230">"Šifriraj?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="3270587498436152259">"Postupak šifriranja je neopoziv te gubite podatke u slučaju prekida. Šifriranje traje jedan sat ili duže, pri čemu se tablet ponovo pokreće nekoliko puta."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="3040428543349852419">"Postupak šifriranja je nepovratan; u slučaju prekida, gubite podatke. Šifriranje traje jedan sat ili duže, pri čemu se telefon ponovo pokreće nekoliko puta."</string>
    <string name="crypt_keeper_setup_title" msgid="3339725741305796680">"Šifriranje"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="4417016995091289019">"Pričekajte dok se tablet šifrira. Dovršeno <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="7902355422499500352">"Pričekajte dok se telefon šifrira. Dovršeno <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="8348188415839917821">"Pričekajte dok se tablet šifrira. Preostalo vrijeme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="8556105766597855198">"Pričekajte dok se telefon šifrira. Preostalo vrijeme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="3832496715430327682">"Da biste otključali tablet, isključite ga, zatim ponovo uključite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="5070346039522135361">"Da biste otključali tablet, isključite ga, a zatim ponovo uključite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="8104921337301750394">"Upozorenje: Preostalo vam je <xliff:g id="COUNT">^1</xliff:g> pokušaja otključavanja, nakon čega će sadržaj vašeg uređaja biti izbrisan!"</string>
    <string name="crypt_keeper_enter_password" msgid="1274917431075529732">"Otkucajte lozinku"</string>
    <string name="crypt_keeper_failed_title" msgid="8173654570682244149">"Šifriranje nije uspjelo"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="5977961188966570342">"Šifriranje je prekinuto te se ne može završiti. Zbog toga podaci sa vašeg tableta više nisu dostupni. \n\n Da biste nastavili koristiti tablet, treba da izvršite vraćanje tableta na fabričke postavke. Nakon što izvršite postavke tableta nakon vraćanja na fabričke postavke, moći ćete vratiti sve podatke za koje postoji sigurnosna kopija na Google računu."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="1028716993071131029">"Šifriranje je prekinuto te se ne može završiti. Zbog toga podaci sa vašeg telefona više nisu dostupni. \n\nDa biste nastavili koristiti telefon, treba da izvršite vraćanje telefona na fabričke postavke. Nakon što izvršite postavke telefona nakon vraćanja na fabričke postavke, moći ćete vratiti sve podatke za koje postoji sigurnosna kopija na Google računu."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="5920153462176846037">"Dešifriranje nije uspjelo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="4420666705959562753">"Unesena lozinka je ispravna, ali nažalost vaši podaci su oštećeni. \n\nDa biste nastavili koristiti tablet, morate izvršiti vraćanje na fabričke postavke. Prilikom podešavanja tableta nakon ponovnog postavljanja, imat ćete priliku da vratite podatke čija sigurnosna kopija je spremljena u vaš Google račun."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="3200498792238652367">"Unesena lozinka je ispravna, ali nažalost vaši podaci su oštećeni. \n\nDa biste nastavili koristiti telefon, morate izvršiti vraćanje na fabričke postavke. Prilikom podešavanja telefona nakon ponovnog postavljanja, imat ćete priliku da vratite podatke čija sigurnosna kopija je spremljena u vaš Google račun."</string>
    <string name="crypt_keeper_switch_input_method" msgid="7712732134989470573">"Promjena načina unosa"</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Zaštitite telefon"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="3213718550422761562">"Postavite zaključavanje ekrana da zaštitite tablet"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="8479766049078378225">"Postavite zaključavanje ekrana da zaštitite uređaj"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="2443273582716671033">"Postavite zaključavanje ekrana da zaštitite telefon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Dodajte otisak prsta da otključate"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="1040265358906410746"></string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Zaključavanje ekrana"</string>
    <string name="lock_settings_picker_title_profile" msgid="8377696902400733227">"Odaberi zaklj. profila"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="1276283007274778191">"Zaštitite svoj tablet"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="3585905639045649905">"Zaštitite svoj uređaj"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="2758197863515864300">"Zaštitite svoj telefon"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Za dodatnu sigurnost, postavite alternativni način zaključavanja ekrana"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="4870877800737248926">"Spriječite da druge osobe koriste ovaj tablet bez vašeg odobrenja tako što ćete aktivirati funkcije za zaštitu uređaja. Odaberite koji način zaključavanja ekrana želite koristiti."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="8961855222808442301">"Spriječite da druge osobe koriste ovaj uređaj bez vašeg odobrenja tako što ćete aktivirati funkcije za zaštitu uređaja. Odaberite koji način zaključavanja ekrana želite koristiti."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="8867435145945818970">"Spriječite da druge osobe koriste ovaj telefon bez vašeg odobrenja tako što ćete aktivirati funkcije za zaštitu uređaja. Odaberite koji način zaključavanja ekrana želite koristiti."</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Odaberite rezervni način zaključavanja ekrana"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opcije zaključavanja ekrana"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opcije zaključavanja ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5799070517574360310">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / odmah nakon izlaska iz stanja mirovanja"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4572132216801894216">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> nakon izlaska iz stanja mirovanja"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zaključ. radnog prof."</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="4746783679112447948">"Promijeni zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="6023813780512501969">"Promijeni ili onemog. uzorak, PIN ili lozinku"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="1699993191343299179">"Odaberite način za zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ništa"</string>
    <string name="unlock_set_unlock_off_summary" msgid="4578319976164001322"></string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Prevlačenje prstom"</string>
    <string name="unlock_set_unlock_none_summary" msgid="641298008390890152">"Nema sigurnosti"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Uzorak"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="4482018884090552709">"Srednja sigurnost"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="1961863114590024945">"Srednja do visoka sigurnost"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Lozinka"</string>
    <string name="unlock_set_unlock_password_summary" msgid="7647435233968707432">"Visoka sigurnost"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ne sada"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Trenutni način zaključavanja ekrana"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Otisak prsta i uzorak"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Otisak prsta i PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Otisak prsta i lozinka"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Nastavi bez postavljanja otiska prsta"</string>
    <string name="fingerprint_unlock_title" msgid="4978686534505944042">"Možete otključati telefon pomoću otiska prsta. Iz sigurnosnih razloga ova opcija zahtijeva alternativni način zaključavanja ekrana."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="5991691559532427891">"Otključavanje licem + uzorak"</string>
    <string name="face_unlock_set_unlock_pin" msgid="8990569318587034610">"Otključavanje licem + PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8612535943511761549">"Otključavanje licem + lozinka"</string>
    <string name="face_unlock_skip_face" msgid="7117201898540606846">"Nastavite s otključavanjem licem"</string>
    <string name="face_unlock_title" msgid="7344830351598247267">"Možete otključati telefon pomoću svog lica. Iz sigurnosnih razloga ova opcija zahtijeva alternativni način zaključavanja ekrana."</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8871485472202659">"Biometrija + uzorak"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="1729940978662427512">"Biometrija + PIN"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="5368133215008755916">"Biometrija + lozinka"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="8260715582785687329">"Nastavite bez biometrije"</string>
    <string name="biometrics_unlock_title" msgid="7769374223959937435">"Telefon možete otključati pomoću biometrije. Iz sigurnosnih razloga ova opcija zahtijeva rezervni način zaključavanja ekrana."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="4022867760387966129">"Onemogućio administrator, pravila šifriranja ili pohrana akreditiva"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ništa"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Prevlačenje prstom"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Uzorak"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Lozinka"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="5974580769186206478">"Kada postavite zaključavanje ekrana, možete postaviti i otisak prsta u Postavke i Sigurnost."</string>
    <string name="unlock_disable_lock_title" msgid="2564279819907932759">"Isključi zaključavanje ekrana"</string>
    <string name="unlock_disable_frp_warning_title" msgid="1520689401825045809">"Ukloniti zaštitu uređaja?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Želite li ukloniti zaštitu profila?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="669384600341275312">"Funkcije za zaštitu uređaja neće funkcionirati bez uzorka."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="8160948976853039106">"Funkcije za zaštitu uređaja neće raditi bez uzorka.<xliff:g id="EMPTY_LINE">

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

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

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

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

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

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

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

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog profila i nećete ih moći koristiti za otključavanje profila, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="621607297961726537">"Da, ukloni"</string>
    <string name="unlock_change_lock_pattern_title" msgid="8234523589333929193">"Promijeni uzorak za otključavanje"</string>
    <string name="unlock_change_lock_pin_title" msgid="2324077520816477479">"Prom. PIN za otključ."</string>
    <string name="unlock_change_lock_password_title" msgid="873517913969091074">"Promijeni lozinku za otključavanje"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže jak PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novi PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novi uzorak, PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novo zaključavanje ekrana"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"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="7450322567217745999">"Vaši podaci će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ako u sljedećem pokušaju unesete neispravan obrazac, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ako u sljedećem pokušaju unesete neispravan PIN, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ako u sljedećem pokušaju unesete neispravnu lozinku, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ako u sljedećem pokušaju unesete neispravan obrazac, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ako u sljedećem pokušaju unesete neispravan PIN, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ako u sljedećem pokušaju unesete neispravnu lozinku, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ako u sljedećem pokušaju unesete neispravan uzorak, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ako u sljedećem pokušaju unesete neispravan PIN, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ako u sljedećem pokušaju unesete neispravnu lozinku, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="2813744895409014471">"Previše je neispravnih pokušaja. Podaci ovog uređaja će se izbrisati."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="3958755474620948727">"Previše je neispravnih pokušaja. Ovaj korisnik će se izbrisati."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="3171880997211568208">"Previše je neispravnih pokušaja. Ovaj radni profil i njegovi podaci će se izbrisati."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="170155081899679669">"Odbaci"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="2192234965414232157">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> znak</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> znaka</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> znakova</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="6817086810898414162">
      <item quantity="one">PIN mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifru</item>
      <item quantity="few">PIN mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifre</item>
      <item quantity="other">PIN mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifara</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="2507983991979547816">"Nastavi"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="8118091957172967677">
      <item quantity="one">Ukupan broj znakova mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="few">Ukupan broj znakova mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="other">Ukupan broj znakova mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="8706992338720310765">
      <item quantity="one">Ukupan broj cifara mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="few">Ukupan broj cifara mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="other">Ukupan broj cifara mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
    </plurals>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Administrator uređaja ne dozvoljava korištenje nedavnog PIN-a"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Ne može sadržavati nevažeći znak"</string>
    <string name="lockpassword_password_requires_alpha" msgid="721084100957669018">"Mora sadržavati najmanje jedno slovo"</string>
    <string name="lockpassword_password_requires_digit" msgid="312518567592683795">"Mora sadržavati najmanje jednu cifru"</string>
    <string name="lockpassword_password_requires_symbol" msgid="6178512486154701321">"Mora sadržavati najmanje jedan simbol"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="2385916409676839024">
      <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="2057467885488612701">
      <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="4541266279643052025">
      <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="70617964591376248">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> cifru</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> cifre</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> cifara</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="7981236881269921943">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebni znak</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebna znaka</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebnih znakova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="1567877061888948467">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znak koji nije slovo</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znaka koja nisu slova</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znakova koji nisu slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonnumerical" formatted="false" msgid="5056743974888384475">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znak koji nije broj</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znaka koji nisu brojevi</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znakova koji nisu brojevi</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Administrator uređaja ne dozvoljava korištenje nedavne lozinke"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Nije dozvoljen rastući, opadajući ili ponavljajući niz cifara"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potvrdite"</string>
    <string name="lockpassword_cancel_label" msgid="6711112212489992112">"Otkaži"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Obriši"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zaključavanje ekrana je već promijenjeno. Pokušajte ponovo s novim zaključavanjem ekrana."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Otkaži"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Naprijed"</string>
    <string name="lock_setup" msgid="4622999020926280737">"Postavljanje je završeno."</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Aplikacije administratora uređaja"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Nema aktivnih aplikacija"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="2528735319390151989">
      <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="6410149930029992356">"Pouzdani agenti"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Da biste ovo koristili, prvo postavite zaključavanje ekrana"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Nema"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="5438047398376802735">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aktivni pouzdani agent</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aktivna pouzdana agenta</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktivnih pouzdanih agenata</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="5955341060378240781">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5257744297562880017">"Uključi Bluetooth"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="6805458703566046784">"Upravljajte vezama, postavite ime uređaja i vidljivost"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Upariti s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Kod za uparivanje putem Bluetootha"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Upišite kod za uparivanje, zatim pritisnite Return ili Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN sadrži slova ili simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Obično 0000 ili 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Mora imati 16 znamenki"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Možda ćete morati otkucati ovaj PIN i na drugom uređaju."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Možda ćete morati otkucati ovaj pristupni kôd na drugom uređaju."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="327192310468680072">"Da biste izvršilu uparivanje s uređajem:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Provjerite da li se prikazuje sljedeći pristupni ključ:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1068123527866596779">"Od:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Želite izvršiti uparivanje s ovim uređajem?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="8672803845151786521">"Da biste izvršili uparivanje s uređajem:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Otkucajte na njemu:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, a zatim pritisnite Return ili Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Dozvolite pristup kontaktima i historiji poziva"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nije uspjelo povezivanje sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="3460316252463771851">"Potraži uređaje"</string>
    <string name="bluetooth_search_for_devices" msgid="6516902340975407648">"Osvježi"</string>
    <string name="bluetooth_searching_for_devices" msgid="6541984133657573124">"Pretraživanje…"</string>
    <string name="bluetooth_preference_device_settings" msgid="1688662188157019998">"Postavke uređaja"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="1090131276572055841">"Upareni uređaj"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="4337953030661626289">"Internet veza"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="8247634441638919886">"Tastatura"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="8194423860397844579">"Kontakti i historija poziva"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="6106058683134173178">"Upariti s ovim uređajem?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="5472835166206721325">"Podijeliti telefonski imenik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="7516277926581535299">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi pristupiti vašim kontaktima i historiji poziva."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="1545098121090892788">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi uparivanje putem Bluetootha. Nakon povezivanja imat će pristup vašim kontaktima i historiji poziva."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dostupni uređaji"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="1331122763066030155">"Nema dostupnih uređaja"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Poveži se"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Prekini vezu"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Upari i poveži"</string>
    <string name="bluetooth_device_context_unpair" msgid="7525735305244087162">"Prekini uparivanje"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="2001359431289794561">"Prekini vezu i uparivanje"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="934657460643490773">"Opcije..."</string>
    <string name="bluetooth_menu_advanced" msgid="7633682234855216066">"Napredno"</string>
    <string name="bluetooth_advanced_titlebar" msgid="5369701494951467257">"Napredni Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Kada je Bluetooth uključen, uređaj može komunicirati s drugim uređajima s Bluetoothom u blizini."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="4069064120315578780">"Kada je uključen Bluetooth, uređaj može komunicirati s Bluetooth uređajima u blizini.\n\nZa bolji doživljaj korištenja uređaja, aplikacije i usluge i dalje mogu u bilo koje vrijeme skenirati uređaje u blizini, čak i kada je Bluetooth isključen. Ovo se može koristiti, naprimjer, za poboljšanje funkcija i usluga zasnovanih na lokaciji. Ovo možete promijeniti u meniju "<annotation id="link">"postavke skeniranja"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1358879010396045164">"Radi poboljšanja preciznosti lociranja, sistemske aplikacije i usluge i dalje mogu prepoznati uređaje s Bluetoothom. Ovo možete promijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="7892663424429584925">"Nije povezan. Pokušajte ponovo."</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detalji o uređaju"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Bluetooth adresa uređaja: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Želite li zaboraviti uređaj?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="4730377171981539265">"Vaš telefon neće više biti uparen s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="3428463407231980054">"Vaš tablet neće više biti uparen s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="5117397433721336918">"Vaš uređaj neće više biti uparen s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="1938465582242297905">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> više neće biti uparen ni sa jednim uređajem povezanim s ovim računom"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Zaboravi uređaj"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="1323072239637864488">"Poveži se na…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="339103864166293612">"Veza uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sa zvukom medija će biti prekinuta."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="7857706184371154920">"Veza uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sa handsfree zvukom će biti prekinuta."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="4794752406024916925">"Veza uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> s ulaznim uređajem će biti prekinuta."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="283176886159444413">"Pristup internetu preko uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> će biti prekinut."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="733193449967330892">"Prekinut će se veza s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> za dijeljenje internetske veze ovog tableta."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="7852265676243153982">"Prekinut će se veza s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> za dijeljenje internetske veze ovog telefona."</string>
    <string name="bluetooth_device_advanced_title" msgid="1181664272013729515">"Upareni Bluetooth uređaj"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="8302236592496988747">"Poveži se"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="271856759516576615">"Poveži se s Bluetooth uređajem"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="7892879890208207223">"Koristi se za"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="4798081898389041132">"Promijeni naziv"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="7604726126703453984">"Dozvoli dolazne transfere fajlova"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="7851033200857999275">"Povezano na uređaj za pristup internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="5563892893331988809">"Dijeljenje lokalne internetske veze s uređajem"</string>
    <string name="bluetooth_dock_settings" msgid="1709536202189755022">"Postavke priključne stanice"</string>
    <string name="bluetooth_dock_settings_title" msgid="4872789068019972847">"Koristi priključnu stanicu za zvuk"</string>
    <string name="bluetooth_dock_settings_headset" msgid="5756482379574272554">"Kao spikerfon"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="434520221656010141">"Za muziku i medijske sadržaje"</string>
    <string name="bluetooth_dock_settings_remember" msgid="6993526033095292609">"Zapamti postavke"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimalan broj povezanih Bluetooth audio uređaja"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Odaberite maksimalan broj povezanih Bluetooth audio uređaja"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Emitiranje"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"preslikavanje"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Omogući bežični prikaz"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Nije pronađen nijedan uređaj u blizini."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Povezuje se"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Povezano"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"U upotrebi"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nedostupan"</string>
    <string name="wifi_display_details" msgid="2351632307998142920">"Postavke ekrana"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opcije Bežičnog prikaza"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Zaboraviti"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Ime"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Prijava"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Otvori web lokaciju"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Još <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Ističe <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_tap_to_sign_in" msgid="8658506618807549483">"Dodirnite ovdje za prijavu na mrežu"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> želi uključiti WiFi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> želi isključiti WiFi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Potvrdi bajtni kôd aplikacija iz kojih se mogu uklanjati greške"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Dopustite ART-u da potvrdi bajtni kôd za aplikacije iz kojih se mogu uklanjati greške"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Prikaži brzinu osvježav."</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Prikaz trenutne brzine osvježavanja ekrana"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="3622326550467939809">"Dozvolite razmjenu podataka kada tablet dodirne NFC uređaj"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="1460871052409162980">"Dozvolite razmjenu podataka kada telefon dodirne NFC uređaj"</string>
    <string name="nfc_disclaimer_title" msgid="3696580694485048039">"Uključite NFC"</string>
    <string name="nfc_disclaimer_content" msgid="8256675597551036207">"NFC razmjenjuje podatke između ovog i drugih uređaja ili ciljeva u blizini, kao što su terminali za plaćanje, čitači pristupa i interaktivni oglasi ili oznake."</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Zahtijevaj otključavanje uređaja za NFC"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="4591286109299690373">"Dozvolite korištenje NFC-a za plaćanje i u javnom prijevozu samo kada je ekran otključan"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Spremno za prijenos sadržaja aplikacije putem NFC-a"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Isključeno"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nedostupno jer je NFC isključen"</string>
    <string name="android_beam_label" msgid="7168565080321110094">"Android Beam"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Kada je uključena ova funkcija, možete emitirati sadržaj aplikacije na drugi uređaj koji podržava NFC približavanjem uređaja jedan drugome. Naprimjer, možete emitirati web stranice, videozapise s YouTubea, kontakte i drugo.\n\nSamo približite uređaje jedan drugome (u pravilu, poleđinu uz poleđinu) a zatim dodirnite svoj ekran. Aplikacija će sama prepoznati šta treba emitirati."</string>
    <string name="wifi_quick_toggle_title" msgid="2737097538432862807">"WiFi"</string>
    <string name="wifi_quick_toggle_summary" msgid="4957267477820468553">"Uključite Wi‑Fi"</string>
    <string name="wifi_settings" msgid="8313301946393559700">"WiFi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Koristi WiFi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"WiFi postavke"</string>
    <string name="wifi_settings_title" msgid="3879649725059512799">"WiFi"</string>
    <string name="wifi_settings_summary" msgid="784074686763572811">"Podešavanje bežičnih pristupnih tačaka i upravljanje njima"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Odaberite WiFi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Uključivanje WiFi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Isključivanje WiFi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Greška"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Opseg od 5 GHz nije dostupan u ovoj zemlji"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"U načinu rada u avionu"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Šalji obavještenja o javnim mrežama"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Obavijesti me kada bude dostupna javna mreža visokog kvaliteta"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Automatski uključi WiFi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"WiFi se automatski ponovo uključuje u blizini sačuvanih mreža visokog kvaliteta, kao što je kućna mreža"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nije dostupno jer je lokacija isključena. Uključite "<annotation id="link">"lokaciju"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="1771489741850119751">"Nije dostupno jer je skeniranje WiFi mreže isključeno"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="3615120120960539780">"Za korištenje funkcije odaberite ocjenjivača mreže"</string>
    <string name="wifi_poor_network_detection" msgid="8210035875160288422">"Izbjegavaj slabe veze"</string>
    <string name="wifi_poor_network_detection_summary" msgid="383834617032605347">"Ne koristi WiFi mrežu, osim ako je internetska veza dobra"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4993203473116721772">"Korištenje samo mreža koje imaju dobru internetsku vezu"</string>
    <string name="use_open_wifi_automatically_title" msgid="7193846454986712009">"Poveži se na javne mreže"</string>
    <string name="use_open_wifi_automatically_summary" msgid="6663890845558591023">"Automatsko povezivanje na javne mreže visokog kvaliteta"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="2299284032301667622">"Za korištenje funkcije odaberite ocjenjivača mreže"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="1780306481499369913">"Za korištenje funkcije odaberite kompatibilnog ocjenjivača mreže"</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instaliranje certifikata"</string>
    <string name="wifi_scan_notify_text" msgid="2518097467707535013">"Kako bi poboljšale preciznost lokacije, aplikacije i usluge mogu i dalje uvijek skenirati WiFi mreže, čak i kada je WiFi isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji. Ovo možete izmijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="6189528915806353667">"Radi poboljšanja preciznosti lociranja, uključite skeniranje WiFi mreža u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="8436897497968907701">"Ne prikazuj ponovo"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="6285374200292675649">"Zadrži WiFi uključenim tokom mirovanja"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8753852404141070878">"WiFi za vrijeme mirovanja"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="4512566787805720422">"Pojavio se problem prilikom mijenjanja postavke"</string>
    <string name="wifi_suspend_efficiency_title" msgid="3589291227092825754">"Poboljšaj učinkovitost"</string>
    <string name="wifi_suspend_optimizations" msgid="5840680940416640209">"Optimizacija WiFi-ja"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="8204170804523356781">"Minimiziraj potrošnju baterije kad je WiFi uključen"</string>
    <string name="wifi_limit_optimizations_summary" msgid="8461087338100462302">"Limit za bateriju za WiFi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="681353878530696197">"Prebaci se na prijenos podataka na mobilnoj mreži ako WiFi izgubi pristup internetu."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automatsko prebacivanje na prijenos podataka na mobilnoj mreži"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Korištenje prijenosa podataka na mobilnoj mreži kada WiFi mreža nema pristup internetu. Mogu nastati troškovi prijenosa podataka."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Dodajte mrežu"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Postavke za WiFi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"WiFi veza se uključuje ponovo automatski"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"WiFi se ne uključuje ponovo automatski"</string>
    <string name="wifi_access_points" msgid="5846755709207101844">"WiFi mreže"</string>
    <string name="wifi_menu_more_options" msgid="1236651929987819716">"Više opcija"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"WiFi Direct"</string>
    <string name="wifi_menu_scan" msgid="3498653582115656526">"Skeniraj"</string>
    <string name="wifi_menu_advanced" msgid="1940919392030994019">"Napredno"</string>
    <string name="wifi_menu_configure" msgid="352423980467311427">"Konfiguriraj"</string>
    <string name="wifi_menu_connect" msgid="7824796427932811078">"Poveži se na mrežu"</string>
    <string name="wifi_menu_remember" msgid="8639523871321603112">"Zapamti mrežu"</string>
    <string name="wifi_menu_forget" msgid="6557142984528657361">"Zaboravi mrežu"</string>
    <string name="wifi_menu_modify" msgid="7246143391161038875">"Modificiraj mrežu"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Da biste vidjeli dostupne mreže, uključite WiFi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="5043989454000825717">"Traženje WiFi mreža..."</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nemate odobrenje za promjenu WiFi mreže."</string>
    <string name="wifi_more" msgid="8742256421693351035">"Još"</string>
    <string name="wifi_setup_wps" msgid="4303694722593999931">"Autom. postavljanje (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Uključiti skeniranje WiFi mreže?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Za automatsko uključivanje WiFi mreže, prvo morate uključiti skeniranje WiFi mreže."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Skeniranje WiFi mreže omogućava aplikacijama i uslugama da traže WiFi mreže u svakom trenutku, čak i kada je WiFi mreža isključena. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Uključi"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Skeniranje WiFi mreže je uključeno"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Napredne opcije"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Padajuća lista Naprednih opcija"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"proširivanje"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Naziv mreže"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Unesite SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sigurnost"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skrivena mreža"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Ukoliko ruter ne emitira ID mreže, ali biste se u buduće željeli povezati na njega, možete postaviti mrežu kao skrivenu.\n\nNa taj način sigurnost može biti ugrožena jer će telefon redovno emitirati signal da pronađe mrežu.\n\nPostavljenjem mreže kao skrivene neće se promijeniti postavke vašeg rutera."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Jačina signala"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Brzina prijenosa veze"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Brzina primanja veze"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Brzina veze"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvencija"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP adresa"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Sačuvano pomoću"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"<xliff:g id="NAME">%1$s</xliff:g> – vjerodajnice"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP metoda"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"2. faza autentifikacije"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA certifikat"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Status online certifikata"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domena"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Korisnički certifikat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identitet"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonimni identitet"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Lozinka"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Prikaži lozinku"</string>
    <string name="wifi_ap_band_config" msgid="1589020070150933055">"Odaberite opseg pristupne tačke"</string>
    <string name="wifi_ap_choose_auto" msgid="8944442003151215691">"Automatski"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Opseg od 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8413248472288180075">"Opseg od 5,0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Preferira se opseg od 5,0 GHz"</string>
    <string name="wifi_ap_2G" msgid="4099628221864343015">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="3493942667238551207">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="5221193733812493435">"Odaberite barem jedan frekvencijski pojas za Wi‑Fi pristupnu tačku:"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP postavke"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privatnost"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Pretplata"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Pregledajte ili promijenite pretplatu"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Nasumično odabrani MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Dodajte uređaj"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centrirajte QR kôd ispod da uređaj dodate na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Skenirajte QR kôd"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centrirajte QR kôd ispod da se povežete na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Skenirajte QR kôd da se pridružite WiFi mreži"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Dijeli WiFi mrežu"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Skenirajte ovaj QR kôd pomoću drugog uređaja da se pridružite mreži “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Skenirajte ovaj QR kôd da se povežete s mrežom “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Pokušajte ponovo. Ako se problem ne riješi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Nešto nije uredu"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Provjerite je li uređaj priključen, napunjen i uključen"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Provjerite je li uređaj priključen, napunjen i uključen. Ako se problem ne riješi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Ovaj uređaj ne podržava dodavanje mreže“<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Pokušajte približiti uređaj WiFi pristupnoj tački/ruteru"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Provjerite lozinku i pokušajte ponovo"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Provjerite vezu i pokušajte ponovo"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Odaberite mrežu"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Za povezivanje uređaja, odaberite mrežu"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Dodati ovaj uređaj na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi mreža je podijeljena s uređajem"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Dodaj još jedan uređaj"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Odaberi drugu mrežu"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Uređaj se ne može dodati"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Uređaj je pronađen"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Dijeljenje WiFi mreže s ovim uređajem…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Povezivanje…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Dijeljenje pristupne tačke"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Potvrdite svoj identitet"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Lozinka WiFi mreže: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Lozinka pristupne tačke: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatsko povezivanje"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Dozvolite povezivanje s ovom mrežom kada je u dometu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Dodaj uređaj"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Dodajte uređaj na ovu mrežu pomoću QR koda"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Format QR koda nije važeći"</string>
    <string name="retry" msgid="7542103800274026915">"Pokušaj ponovo"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Dijeli s ostalim korisnicima uređaja"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nepromijenjeno)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Odaberite"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(dodano je više certifikata)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Koristi certifikate sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ne navodi"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4673867078988209732">"Ne potvrđuj valjanost"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Naziv mreže je predug."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Morate navesti domenu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Potreban je certifikat."</string>
    <string name="wifi_wps_available_first_item" msgid="5780501151792036589">"WPS dostupan"</string>
    <string name="wifi_wps_available_second_item" msgid="1717024103303480804">" (WPS dostupan)"</string>
    <string name="wifi_carrier_connect" msgid="4511538300946413213">"WiFi mreža mobilnog operatera"</string>
    <string name="wifi_carrier_content" msgid="2876499905644083615">"Povežite se putem mobilnog operatera <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Da biste poboljšali preciznost lokacije te u druge svrhe, <xliff:g id="APP_NAME">%1$s</xliff:g> aplikacija želi uključiti skeniranje mreže, čak i kada je WiFi isključen.\n\nŽelite li dozvoliti ovo za sve aplikacije koje žele izvršiti skeniranje?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Da bi poboljšala preciznost lokacije te u druge svrhe, nepoznata aplikacija želi uključiti skeniranje mreže, čak i kada je WiFi isključen.\n\nDozvoliti ovo za sve aplikacije koje žele skenirati?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="93691286302680448">"Da ovo isključite, idite na Napredno u preklopnom meniju."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Dozvoli"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Odbij"</string>
    <string name="wifi_hotspot_title" msgid="1918712370697971229">"Prijavite se za povezivanje?"</string>
    <string name="wifi_hotspot_message" msgid="5245614124614833169">"<xliff:g id="APP_NAME">%1$s</xliff:g> zahtijeva da se prijavite online prije nego se povežete na mrežu."</string>
    <string name="wifi_hotspot_connect" msgid="1916314048788438331">"POVEZATI"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Ova mreža nema pristup internetu. Zadržati povezanost?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Neke aplikacije i usluge možda neće raditi zbog ograničene povezivosti. Ipak koristiti?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ne pitaj me više za ovu mrežu"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"WiFi mreža nije povezana na internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Možete se prebaciti na mobilnu mrežu kad god je Wi‑Fi veza loša. Mogu nastati troškovi prijenosa podataka."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Prebaci na mobilnu mrežu"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Ostani na WiFi mreži"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Nemoj više prikazivati"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Poveži se"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"WiFi je uključen"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Povezano s mrežom <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Povezivanje s mrežom <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Povezivanje…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Povezivanje na mrežu nije uspjelo"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Mreža nije u dometu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Zaboravi"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Izmijeni"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Zaboravljanje mreže nije uspjelo"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Sačuvaj"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Čuvanje mreže nije uspjelo"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Otkaži"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Zaboraviti mrežu?"</string>
    <string name="wifi_forget_dialog_message" msgid="8419499588321940243">"Sve lozinke za ovu mrežu će se izbrisati"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="2802436466732147888">
      <item quantity="one">%d mreža</item>
      <item quantity="few">%d mreže</item>
      <item quantity="other">%d mreža</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="5802057518058840450">
      <item quantity="one">%d pretplata</item>
      <item quantity="few">%d pretplate</item>
      <item quantity="other">%d pretplata</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="5125849180309374451">
      <item quantity="one">%d mreža i pretplata</item>
      <item quantity="few">%d mreže i pretplate</item>
      <item quantity="other">%d mreža i pretplata</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="1234150304285575798">"Napredni WiFi"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"MAC adresa uređaja"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Nasumično odabrana MAC adresa"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Nasumično odabrana MAC adresa (zadnje korišteno)"</string>
    <string name="wifi_advanced_ip_address_title" msgid="4265355419782184514">"IP adresa"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detalji o mreži"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podmreže"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6 adrese"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Sačuvane mreže"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Pretplate"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Druge mreže"</string>
    <string name="wifi_advanced_settings_label" msgid="5880605751602184383">"IP postavke"</string>
    <string name="wifi_advanced_not_available" msgid="8701003884367299092">"Napredne WiFi postavke nisu dostupne za ovog korisnika"</string>
    <string name="wifi_ip_settings_menu_save" msgid="5190481040428567106">"Sačuvaj"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="1757817733064004598">"Otkaži"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Unesite važeću IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Unesite važeću adresu pristupnika."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Unesite važeću DNS adresu."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Unesite dužinu mrežnog prefiksa između 0 i 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (osim ako ga nije poništio privatni DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (osim ako ga nije poništio privatni DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Pristupnik"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Dužina prefiksa mreže"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"WiFi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="4304362679971797283">"Informacije o uređaju"</string>
    <string name="wifi_p2p_persist_network" msgid="7942929491568227945">"Zapamti ovu vezu"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Potraži uređaje"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Pretraživanje…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Promijeni naziv uređaja"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Ravnopravni uređaji"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Zapamćene grupe"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Povezivanje nije uspjelo."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Promjena naziva uređaja nije uspjela."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Prekinuti vezu?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Ako prekinete vezu, okončat će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Ako prekinete vezu, okončat će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g> i još <xliff:g id="PEER_COUNT">%2$s</xliff:g> uređaja."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Otkazati pozivnicu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Da li želite otkazati pozivnicu za povezivanje s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Zaboraviti ovu grupu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"WiFi pristupna tačka"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Nema dijeljenja interneta ili sadržaja s drugim uređajima"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5832429443898690152">"Dijeljenje internetske veze ovog tableta putem pristupne tačke"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5451921191609178326">"Dijeljenje internetske veze ovog telefona putem pristupne tačke"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="965051079784031636">"Aplikacija dijeli sadržaj. Za dijeljenje internetske veze isključite pa uključite pristupnu tačku"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Lozinka nije postavljena"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Naziv pristupne tačke"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="2094754115215428892">"Uključivanje pristupne tačke <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>…"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="6935457127884928249">"Drugi uređaji se mogu povezati na pristupnu tačku <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Lozinka pristupne tačke"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"AP opseg"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="6620216295510397461">"Koristite pristupnu tačku da kreirate Wi‑Fi mrežu za ostale svoje uređaje. Pristupna tačka pruža internet koristeći vašu vezu za prijenos podataka na mobilnoj mreži. Mogu nastati dodatni troškovi prijenosa mobilnih podataka."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="3813311942370920903">"Aplikacije mogu kreirati pristupnu tačku za dijeljenje sadržaja s uređajima u blizini."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Automatski isključi pristupnu tačku"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kada nijedan uređaj nije povezan"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Uključivanje pristupne tačke…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Isključivanje pristupne tačke…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivna"</string>
    <string name="wifi_tether_failed_subtext" msgid="437190628041885500">"Greška kod prijenosne WiFi pristupne tačke"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7072559431286459122">"Postavljanje WiFi pristupne tačke"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="9027072969831022321">"Postavke WiFi pristupne tačke"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="1445157424926935178">"AndroidAP WPA2 PSK pristupna tačka"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Android pristupna tačka"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Sačuvati ovu mrežu?"</string>
    <string name="wifi_add_app_single_network_summary" product="default" msgid="6881712878537666626">"<xliff:g id="APPNAME">%1$s</xliff:g> želi sačuvati mrežu na vaš telefon"</string>
    <string name="wifi_add_app_single_network_summary" product="tablet" msgid="8455616967601552440">"<xliff:g id="APPNAME">%1$s</xliff:g> želi sačuvati mrežu na vaš tablet"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Pohranjivanje…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Sačuvano"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Nije moguće sačuvati. Pokušajte ponovo."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Sačuvati mreže?"</string>
    <string name="wifi_add_app_networks_summary" product="default" msgid="2670215712788515167">"<xliff:g id="APPNAME">%1$s</xliff:g> želi sačuvati ove mreže na vaš telefon"</string>
    <string name="wifi_add_app_networks_summary" product="tablet" msgid="2088967184512169910">"<xliff:g id="APPNAME">%1$s</xliff:g> želi sačuvati ove mreže na vaš tablet"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Čuvanje mreža (<xliff:g id="NUMBER">%d</xliff:g>)…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Mreže su sačuvane"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Proširite mogućnost pozivanja s Wi‑Fi-jem"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Uključite pozivanje putem Wi‑Fi-ja za veću pokrivenost"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Postavka poziva"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Postavka pozivanja"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Postavke rominga"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Postavke rominga"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"WiFi"</item>
    <item msgid="8622872038388687383">"Mobilna mreža"</item>
    <item msgid="3027927219952052398">"Samo WiFi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"WiFi"</item>
    <item msgid="7566603075659706590">"Mobilna mreža"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Ako WiFi nije dostupan, koristi mobilnu mrežu"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Ako mobilna mreža nije dostupna, koristi WiFi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Pozivanje putem WiFi-ja. Ako se izgubi WiFi, poziv će se prekinuti."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kada je opcija Pozivanje putem WiFi-ja uključena, telefon može preusmjeravati pozive putem WiFi mreža ili mreže vašeg operatera, u zavisnosti od toga kakve su vaše postavke i koji signal je jači. Prije nego što uključite ovu funkciju, raspitajte se o naknadi i drugim informacijama kod operatera.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="3490633500025717573">"Adresa za hitne slučajeve"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Koristi se kao vaša lokacija prilikom hitnog poziva putem Wi‑Fi mreže"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Saznajte više"</annotation>" o funkcijama privatnog DNS-a"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Uključeno"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="129524064888622179">"Postavkom upravlja mobilni operater"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivirajte pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Uključite pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_not_supported" msgid="3303917737849393175">"Pozivanje putem WiFi-ja nije podržano za mobilnog operatera %1$s"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Prekinuta je veza s mrežom <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="carrier" msgid="1755020806290963951">"Mobilni operater"</string>
    <string name="display_settings_title" msgid="626835071804834218">"Prikaz"</string>
    <string name="sound_settings" msgid="5514582720435174014">"Zvuk"</string>
    <string name="all_volume_title" msgid="6196367642878437513">"Jačine zvuka"</string>
    <string name="musicfx_title" msgid="5458574743312283473">"Muzički efekti"</string>
    <string name="ring_volume_title" msgid="4869034595079914541">"Jačina zvuka zvona i obavještenja"</string>
    <string name="vibrate_in_silent_title" msgid="5076579100685867363">"Vibriraj u nečujnom načinu rada"</string>
    <string name="notification_sound_title" msgid="8747567935870133157">"Zadani zvuk obavještenja"</string>
    <string name="incoming_call_volume_title" msgid="8445408274513654261">"Melodija zvona"</string>
    <string name="notification_volume_title" msgid="328053763590888609">"Obavještenje"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1798481722572489141">"Koristi jačinu zvuka dolaznih poziva za obavještenja"</string>
    <string name="home_work_profile_not_supported" msgid="2605589489324241338">"Ne podržava radne profile"</string>
    <string name="notification_sound_dialog_title" msgid="7431891669251806266">"Zadani zvuk obavještenja"</string>
    <string name="media_volume_title" msgid="5209147840160985178">"Mediji"</string>
    <string name="media_volume_summary" msgid="4671324482655564873">"Postavi jačinu zvuka za muziku i video zapise"</string>
    <string name="alarm_volume_title" msgid="706302621191735343">"Alarm"</string>
    <string name="dock_settings_summary" msgid="8548721822219932359">"Postavke zvuka za priloženu priključnu stanicu"</string>
    <string name="dtmf_tone_enable_title" msgid="2241337296249130217">"Tonovi prilikom dodirivanja tastature telefona"</string>
    <string name="sound_effects_enable_title" msgid="328569690466233866">"Zvukovi dodira"</string>
    <string name="lock_sounds_enable_title" msgid="804365014499259673">"Zvuk zaključavanja ekrana"</string>
    <string name="audio_record_proc_title" msgid="486071779724181619">"Poništavanje buke"</string>
    <string name="volume_media_description" msgid="2736061076584067204">"Muzika, video, igre i drugi medijski sadržaji"</string>
    <string name="volume_ring_description" msgid="5423168446359881864">"Melodija zvona i obavještenja"</string>
    <string name="volume_notification_description" msgid="3241009629930030492">"Obavještenja"</string>
    <string name="volume_alarm_description" msgid="156563371961039376">"Alarmi"</string>
    <string name="volume_ring_mute" msgid="1445718401945149622">"Isključi zvuk melodije zvona i obavještenja"</string>
    <string name="volume_media_mute" msgid="1881020121757820746">"Isključi zvuk za muziku i druge medijske sadržaje"</string>
    <string name="volume_notification_mute" msgid="2612197659377126312">"Isključi zvuk obavještenja"</string>
    <string name="volume_alarm_mute" msgid="3730895630530980760">"Isključi zvuk alarma"</string>
    <string name="dock_settings" msgid="4654404127402812514">"Priključna stanica"</string>
    <string name="dock_settings_title" msgid="1276956575555480214">"Postavke priključne stanice"</string>
    <string name="dock_audio_settings_title" msgid="8294821925086965934">"Zvuk"</string>
    <string name="dock_audio_summary_desk" msgid="4158593887711452737">"Postavke za priloženu priključnu stanicu za radni sto"</string>
    <string name="dock_audio_summary_car" msgid="292911654994476080">"Postavke za prikačeni mobilni držač za auto"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="7758416095500202500">"Tablet nije u priključnoj stanici"</string>
    <string name="dock_audio_summary_none" product="default" msgid="9056359991181743485">"Telefon nije u priključnoj stanici"</string>
    <string name="dock_audio_summary_unknown" msgid="5486086330763810318">"Postavke za priloženu priključnu stanicu"</string>
    <string name="dock_not_found_title" msgid="4721157149003423417">"Priključna stanica nije pronađena"</string>
    <string name="dock_not_found_text" product="tablet" msgid="9192097687086523411">"Trebate staviti tablet u priključnu stanicu prije postavljanja zvuka za priključnu stanicu."</string>
    <string name="dock_not_found_text" product="default" msgid="2247163115146852069">"Trebate staviti telefon u priključnu stanicu prije postavljanja zvuka za priključnu stanicu."</string>
    <string name="dock_sounds_enable_title" msgid="2974614136344237932">"Zvuk prilikom umetanja u priključnu stanicu"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="468592489565539336">"Reproduciraj zvuk prilikom stavljanja ili vađenja tableta iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8121670617316301768">"Reproduciraj zvuk prilikom stavljanja ili vađenja telefona iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="7833926726878567889">"Zvuk se ne reprodukuje prilikom uključivanja tableta u priključnu stanicu ili njegovog isključivanja iz nje"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="5560601997128422001">"Zvuk se ne reprodukuje prilikom uključivanja telefona u priključnu stanicu ili njegovog isključivanja iz nje"</string>
    <string name="account_settings" msgid="255404935489127404">"Računi"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Računi radnog profila – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Računi ličnog profila"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Račun za Work – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Lični račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Pretraži"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ekran"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automatsko rotiranje ekrana"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Boje"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Prirodne"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Pojačane"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Zasićene"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Prilagodljive"</string>
    <string name="color_mode_summary_natural" msgid="8298840714001791628">"Koristi samo precizne boje"</string>
    <string name="color_mode_summary_automatic" msgid="8157885594041700275">"Prilagodite između izraženih i preciznih boja"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="6413384391658481700">"Automatski promijeni orijentaciju prilikom rotiranja tableta"</string>
    <string name="accelerometer_summary_on" product="default" msgid="7117139542131700779">"Automatski promijeni orijentaciju prilikom rotiranja telefona"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="3747370091309939684">"Automatski promijeni orijentaciju prilikom rotiranja tableta"</string>
    <string name="accelerometer_summary_off" product="default" msgid="4451125241783158763">"Automatski promijeni orijentaciju prilikom rotiranja telefona"</string>
    <string name="brightness" msgid="6216871641021779698">"Nivo osvjetljenja"</string>
    <string name="brightness_title" msgid="5457874893085305155">"Osvjetljenje"</string>
    <string name="brightness_summary" msgid="6309641759293018049">"Prilagodite osvjetljenje ekrana"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Prilagodljiva osvijetljenost"</string>
    <string name="auto_brightness_summary" msgid="1737148869232725883">"Osvijetljenost ekrana se prilagođava okruženju"</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Uključeno"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Isključeno"</string>
    <string name="auto_brightness_summary_very_low" msgid="2705445901659224330">"Preferirani nivo osvjetljenja je veoma nizak"</string>
    <string name="auto_brightness_summary_low" msgid="1606100911112851291">"Preferirani nivo osvjetljenja je nizak"</string>
    <string name="auto_brightness_summary_default" msgid="9038441148247815684">"Preferirani nivo osvjetljenja je zadani"</string>
    <string name="auto_brightness_summary_high" msgid="2886260311484349010">"Preferirani nivo osvjetljenja je visok"</string>
    <string name="auto_brightness_summary_very_high" msgid="8294814315426024005">"Preferirani nivo osvjetljenja je veoma visok"</string>
    <string name="auto_brightness_off_title" msgid="5156056957376839677">"Isključeno"</string>
    <string name="auto_brightness_very_low_title" msgid="618973599332847430">"Veoma nizak"</string>
    <string name="auto_brightness_low_title" msgid="4243763334776382492">"Nizak"</string>
    <string name="auto_brightness_default_title" msgid="1776584786251120907">"Zadano"</string>
    <string name="auto_brightness_high_title" msgid="6472704542949390468">"Visok"</string>
    <string name="auto_brightness_very_high_title" msgid="4935132626750630713">"Veoma visok"</string>
    <string name="auto_brightness_subtitle" msgid="6839449395639517870">"Vaš preferirani nivo osvjetljenja"</string>
    <string name="auto_brightness_off_summary" msgid="4993150980274474226">"Ne podešavaj prema dostupnom svjetlu"</string>
    <string name="auto_brightness_very_high_summary" msgid="2784981315548144255">"Povećana potrošnja baterije"</string>
    <string name="auto_brightness_disclaimer" msgid="1868395832774087351">"Optimizirajte nivo osvjetljenja prema dostupnom svjetlu. Kada je ova funkcija uključena i dalje možete privremeno podešavati nivo osvjetljenja."</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Osvijetljenost ekrana će se automatski prilagođavati vašem okruženju i aktivnostima. Klizač možete ručno pomjerati kako bi prilagodljiva osvijetljenost zapamtila vaše postavke."</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Balans bijele boje prikaza"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Glatki prikaz"</string>
    <string name="peak_refresh_rate_summary" msgid="1527087897198455042">"Automatski povećava interval osvježavanja sa 60 na 90 Hz za određeni sadržaj. Povećava potrošnju baterije."</string>
    <string name="force_high_refresh_rate_toggle" msgid="5861514655252832828">"Nametni brzinu osvježavanja od 90 Hz"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Najveća brzina osvježavanja za poboljšanu reakciju na dodir i kvalitet animacije. Povećava potrošnju baterije."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Svjesni ekran"</string>
    <string name="adaptive_sleep_summary_on" msgid="313187971631243800">"Uključeno / ekran se neće isključiti ako gledate u njega"</string>
    <string name="adaptive_sleep_summary_off" msgid="5272156339202897523">"Isključeno"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Potreban je pristup kameri"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5107880175176848307">"Dodirnite da upravljate odobrenjima za Usluge personalizacije uređaja"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Sprečava isključivanje ekrana ako gledate u njega"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Funkcija Svjesni ekran koristi prednju kameru da utvrdi gleda li neko u ekran. Funkcionira na uređaju, a slike se nikada ne arhiviraju niti šalju Googleu."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Uključite svjesni ekran"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Zadržava ekran uključenim dok gledate u njega"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Noćno svjetlo"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Noćno svjetlo oboji ekran u žutosmeđe. Tako je lakše gledati u ekran ili čitati pod prigušenim svjetlom, a može vam pomoći da lakše zaspite."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Raspored"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Ništa"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Uključuje se u zadano vrijeme"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Uključeno od sumraka do svitanja"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Vrijeme početka"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Vrijeme završetka"</string>
    <string name="night_display_status_title" msgid="9006282950657941820">"Status"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intenzitet"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Neće se nikada automatski uključiti"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Automatski će se uključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Automatski će se uključiti u sumrak"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Neće se nikada automatski isključiti"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Automatski će se isključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Automatski će se isključiti u svitanje"</string>
    <string name="night_display_activation_on_manual" msgid="7999294858026069365">"Uključi sada"</string>
    <string name="night_display_activation_off_manual" msgid="4842907786868153218">"Isključi sada"</string>
    <string name="night_display_activation_on_twilight" msgid="3440889451767582067">"Uključi do izlaska sunca"</string>
    <string name="night_display_activation_off_twilight" msgid="2853594955401726956">"Isključi do zalaska sunca"</string>
    <string name="night_display_activation_on_custom" msgid="4951143503599226846">"Uključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="79965738861100371">"Isključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Noćno svjetlo nije uključeno"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Da bi se odredio zalazak i izlazak sunca, potrebna je lokacija uređaja."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Postavke lokacije"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Uključi sada"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Isključi sada"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Uključi do izlaska sunca"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Isključi do zalaska sunca"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Način rada po mraku"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Raspored"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Ništa"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Uključeno od sumraka do svitanja"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Uključuje se u zadano vrijeme"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Neće se nikada automatski uključiti"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Automatski će se uključiti u sumrak"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Automatski će se uključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Neće se nikada automatski isključiti"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Automatski će se isključiti u svitanje"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Automatski će se isključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_on_custom" msgid="1889379402860316125">"Uključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_off_custom" msgid="2192932161592759607">"Isključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tamna tema koristi crnu pozadinu da bi se trajanje baterije produžilo na nekim ekranima. Tamna tema zakazuje čekanje uključivanja dok se ekran ne isključi."</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Istek vremena ekrana"</string>
    <string name="screen_timeout_title" msgid="785134393520893049">"Ekran se isključuje"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Nakon <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Pozadinska slika"</string>
    <string name="style_and_wallpaper_settings_title" msgid="7580575814098427579">"Stilovi i pozadinske slike"</string>
    <string name="wallpaper_settings_summary_default" msgid="7569803705735001813">"Zadano"</string>
    <string name="wallpaper_settings_summary_custom" msgid="3174561317688848729">"Prilagođeno"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Promijenite pozadinsku sliku"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Prilagodite svoj ekran"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Odabir pozadinske slike iz"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Prilagodite telefon"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Isprobajte različite stilove, pozadinske slike i još mnogo toga"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Čuvar ekrana"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Tokom punjenja ili kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_either_short" msgid="2126139984738506920">"Bilo koje"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Tokom punjenja"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nikada"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Isključeno"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1166343194760238835">"Za kontrolisanje dešavanja kada je telefon priključen i/ili dok miruje, uključi čuvara ekrana."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kada početi"</string>
    <string name="screensaver_settings_current" msgid="390472865895976891">"Trenutni čuvar ekrana"</string>
    <string name="screensaver_settings_dream_start" msgid="6486360145976995856">"Započni odmah"</string>
    <string name="screensaver_settings_button" msgid="6159236558934930238">"Postavke"</string>
    <string name="automatic_brightness" msgid="4599827881929079513">"Automatsko osvjetljenje"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Podignite za buđenje"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambijentalni prikaz"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kada prikazati"</string>
    <string name="doze_title" msgid="1523090408230862316">"Akt. ekrana radi obavještenja"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kada je ekran zatamnjen, uključuje se zbog novih obavještenja"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Uvijek prikaži vrijeme i info."</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Povećana potrošnja baterije"</string>
    <string name="force_bold_text" msgid="3636373986786504634">"Boldiranje teksta"</string>
    <string name="title_font_size" msgid="570613010306330622">"Veličina fonta"</string>
    <string name="short_summary_font_size" msgid="184712645848458143">"Povećajte ili smanjite tekst"</string>
    <string name="sim_lock_settings" msgid="4493069398250139205">"Postavke zaključavanja SIM kartice"</string>
    <string name="sim_lock_settings_category" msgid="4280307997492851625">"Zaključavanje SIM kartice"</string>
    <string name="sim_lock_settings_summary_off" msgid="4570941250786847095">"Isključeno"</string>
    <string name="sim_lock_settings_summary_on" msgid="1562184566830887925">"Zaključano"</string>
    <string name="sim_lock_settings_title" msgid="1401619059761012696">"Zaključavanje SIM kartice"</string>
    <string name="sim_pin_toggle" msgid="98754920202404425">"Zaključaj SIM karticu"</string>
    <string name="sim_lock_on" product="tablet" msgid="5857965768682972363">"Zahtijevaj PIN za korištenje tableta"</string>
    <string name="sim_lock_on" product="default" msgid="3303147192981388923">"Potreban je PIN za korištenje telefona"</string>
    <string name="sim_lock_off" product="tablet" msgid="7188936582548721225">"Zahtijevaj PIN za korištenje tableta"</string>
    <string name="sim_lock_off" product="default" msgid="4634118006847137785">"Potreban je PIN za korištenje telefona"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Promjena PIN-a SIM kartice"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN za SIM"</string>
    <string name="sim_enable_sim_lock" msgid="8993991669975548653">"Zaključavanje SIM kartice"</string>
    <string name="sim_disable_sim_lock" msgid="7656447857474746157">"Otključajte SIM karticu"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Stari PIN za SIM"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Novi PIN za SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Ponovo unesite novi PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN za SIM"</string>
    <string name="sim_bad_pin" msgid="5416328363761048221">"Pogrešan PIN"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN-ovi se ne podudaraju"</string>
    <string name="sim_change_failed" msgid="316723087029061740">"Nije moguće promijeniti PIN.\nMožda je PIN neispravan."</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN za SIM uspješno promijenjen"</string>
    <string name="sim_lock_failed" msgid="16360418201678317">"Ne možete otključati SIM.\nPIN je možda pogrešan."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Onemogućavanje PIN-a nije uspelo."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Omogućavanje PIN-a nije uspelo."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Uredu"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Otkaži"</string>
    <string name="sim_multi_sims_title" msgid="4875083890014013296">"Pronađeno više SIM-ova"</string>
    <string name="sim_multi_sims_summary" msgid="1711012455679332238">"Odaberite željenu SIM karticu za prijenos podataka na mobilnoj mreži."</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Koristiti <xliff:g id="CARRIER">%1$s</xliff:g> za mobilne podatke?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Koristite <xliff:g id="CARRIER2_0">%2$s</xliff:g> za prijenos podataka na mobilnoj mreži. Ako se prebacite na operatera <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> se više neće koristiti za prijenos podataka na mobilnoj mreži."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Koristi <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="7182406911552216373">"Ažurirati željenu SIM karticu?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"SIM kartica <xliff:g id="NEW_SIM">%1$s</xliff:g> jedina je SIM kartica u vašem uređaju. Želite li tu SIM karticu koristiti za prijenos podataka na mobilnoj mreži, pozive i SMS poruke?"</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"PIN za SIM je netačan. Za otključavanje uređaja sada morate kontaktirati svog operatera."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="4054088588731305475">
      <item quantity="one">PIN za SIM je netačan. Preostao vam je još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaj.</item>
      <item quantity="few">PIN za SIM je netačan. Preostala su vam još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
      <item quantity="other">PIN za SIM je netačan. Preostalo vam je još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
    </plurals>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"PIN kôd za SIM je netačan. Imate još 1 pokušaj prije nego što budete morali kontaktirati operatera da bi otključao uređaj."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operacija PIN-a za SIM nije uspjela!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Ažuriranja sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Verzija Androida"</string>
    <string name="security_patch" msgid="4071756145347865382">"Sigurnosno ažuriranje za Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_info" msgid="7035211991066637019">"Model i hardver"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Verzija hardvera"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID opreme"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Verzija nemoduliranog signala"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Osnovna verzija"</string>
    <string name="build_number" msgid="9009733242117579826">"Broj verzije"</string>
    <string name="module_version" msgid="1787518340082046658">"Ažuriranje sistema Google Playa"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nije dostupno"</string>
    <string name="device_status_activity_title" msgid="1812666241137263882">"Status"</string>
    <string name="device_status" msgid="7988547478034984649">"Status"</string>
    <string name="device_status_summary" product="tablet" msgid="8826216824111648900">"Status baterije, mreže i druge informacije"</string>
    <string name="device_status_summary" product="default" msgid="8132661857066128832">"Broj telefona, signal itd."</string>
    <string name="storage_settings" msgid="7472188817781592677">"Pohrana"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Pohrana i keš memorija"</string>
    <string name="storage_usb_settings" msgid="7058142934214211583">"Memorija"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Postavke za pohranu"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3858049818577638926">"Deaktiviraj USB pohranu, prikaži dostupnu pohranu"</string>
    <string name="storage_settings_summary" product="default" msgid="267557695753980969">"Deaktiviraj SD karticu, prikaži dostupnu pohranu"</string>
    <string name="imei_multi_sim" msgid="71477088017585479">"IMEI (utor za sim %1$d)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Za prikaz odaberite sačuvanu mrežu"</string>
    <string name="status_number" product="tablet" msgid="3597945414666253183">"MDN"</string>
    <string name="status_number" product="default" msgid="8407999629121682207">"Broj telefona"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="6582203988975619529">"MDN (utor za sim %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="5724823197745786398">"Broj telefona (utor za sim %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="4239876366511743428">"MDN na SIM-u"</string>
    <string name="status_number_sim_status" product="default" msgid="2772745542921910086">"Broj telefona na SIM-u"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Verzija PRL-a"</string>
    <string name="meid_multi_sim" msgid="7645394486193991388">"MEID (utor za sim %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="7644609329607744714">"Uključeno je i WiFi i Bluetooth skeniranje"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="7215007787287418186">"Uključeno je WiFi skeniranje, isključeno je Bluetooth skeniranje"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="1396882599556304165">"Uključeno je Bluetooth skeniranje, isključeno je WiFi skeniranje"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="7670694707427030537">"Isključeno je i Wifi i Bluetooth skeniranje"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Vrsta mreže za prijenos podataka"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Vrsta mreže za glasovne pozive"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informacije o operateru"</string>
    <string name="status_data_state" msgid="525196229491743487">"Stanje mobilne mreže"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Stanje usluge"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Jačina signala"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Mreža"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"MAC adresa WiFi mreže"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"MAC adresa uređaja za WiFi mrežu"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth adresa"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Serijski broj"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Vrijeme aktivnosti"</string>
    <string name="status_awake_time" msgid="2573925324168081586">"Vrijeme aktivnosti"</string>
    <string name="internal_memory" msgid="1869518160077033848">"Unutrašnja pohrana"</string>
    <string name="sd_memory" product="nosdcard" msgid="5456718463397723781">"USB pohrana"</string>
    <string name="sd_memory" product="default" msgid="3098344183202722455">"SD kartica"</string>
    <string name="memory_available" msgid="712528795743654737">"Dostupno"</string>
    <string name="memory_available_read_only" msgid="3201969221573511590">"Dostupno (samo za čitanje)"</string>
    <string name="memory_size" msgid="2710897518522931469">"Ukupni prostor"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Računanje…"</string>
    <string name="memory_apps_usage" msgid="8818570780540532952">"Aplikacije i podaci aplikacija"</string>
    <string name="memory_media_usage" msgid="5161308657995646963">"Mediji"</string>
    <string name="memory_downloads_usage" msgid="8252462247720191179">"Preuzimanja"</string>
    <string name="memory_dcim_usage" msgid="3568913845973164352">"Slike, videozapisi"</string>
    <string name="memory_music_usage" msgid="8100634000114206429">"Zvuk (muzika, melodije zvona, podcasti itd.)"</string>
    <string name="memory_media_misc_usage" msgid="7066851245178533269">"Drugi fajlovi"</string>
    <string name="memory_media_cache_usage" msgid="780808666853685824">"Keširani podaci"</string>
    <string name="sd_eject" product="nosdcard" msgid="6136102589751843304">"Deaktiviraj dijeljenu pohranu"</string>
    <string name="sd_eject" product="default" msgid="8062832622096296251">"Deaktiviraj SD karticu"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="6859940774161708871">"Deaktiviraj internu USB pohranu"</string>
    <string name="sd_eject_summary" product="default" msgid="5151243312587186226">"Demontirajte SD karticu kako biste je mogli bezbjedno ukloniti"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="9164545135649775664">"Umetnite USB pohranu za aktiviranje"</string>
    <string name="sd_insert_summary" product="default" msgid="5949168259622002192">"Umetnite SD karticu za aktiviranje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8305985249945415150">"Aktivirajte USB pohranu"</string>
    <string name="sd_mount" product="default" msgid="5279813999455776169">"Aktivirajte SD karticu"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="2190410240845521205"></string>
    <string name="sd_mount_summary" product="default" msgid="2190410240845521205"></string>
    <string name="sd_format" product="nosdcard" msgid="8657427883364711513">"Izbriši USB pohranu"</string>
    <string name="sd_format" product="default" msgid="9085302892248732329">"Izbriši SD karticu"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6179784504937189658">"Briše sve podatke na unutrašnjoj USB pohrani, kao što su muzika i fotografije"</string>
    <string name="sd_format_summary" product="default" msgid="60583152211068164">"Briše sve podatke na SD kartici, kao što su muzika i fotografije"</string>
    <string name="memory_clear_cache_title" msgid="2605096903803953619">"Želite li zbrisati keširane podatke?"</string>
    <string name="memory_clear_cache_message" msgid="4759561226480906588">"Ovo briše keširane podatke za sve aplikacije."</string>
    <string name="mtp_ptp_mode_summary" msgid="7969656567437639239">"Funkcija MTP ili PTP je aktivna"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="7694112411895701320">"Deaktivirati USB pohranu?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="8251329019960361646">"Deaktivirati SD karticu?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="1212025106709645023">"Ako deaktivirate USB pohranu, neke aplikacije koje koristite će prestati raditi i može se desiti da budu nedostupne dok ponovo ne aktivirate USB pohranu."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="3887768438615563697">"Ako deaktivirate SD karticu, neke aplikacije koje koristite će prestati raditi i može se desiti da budu nedostupne dok ponovo ne aktivirate SD karticu."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="7876201891724279436">"USB pohrana se ne može isključiti. Pokušajte ponovo kasnije."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="2185659901137961711">"Nije bilo moguće odvojiti SD karticu. Pokušajte ponovo kasnije."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="5932607205977999175">"USB pohrana će biti deaktivirana."</string>
    <string name="unmount_inform_text" product="default" msgid="716578785262713312">"SD kartica će biti deaktivirana."</string>
    <string name="sd_ejecting_title" msgid="1641122369013595273">"Deaktiviranje"</string>
    <string name="sd_ejecting_summary" msgid="861928572729341132">"Deaktiviranje u toku"</string>
    <string name="storage_low_title" msgid="8002650511493419567">"Prostor za pohranu ponestaje"</string>
    <string name="storage_low_summary" msgid="7341022293583384506">"Neke funkcije sistema, kao što je sinhronizacija, možda neće raditi ispravno. Pokušajte osloboditi prostor brisanjem ili deaktiviranjem stavki kao što su aplikacije ili medijski sadržaj."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Promijeni naziv"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Montiraj"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Izbaci"</string>
    <string name="storage_menu_format" msgid="5454870642788909443">"Formatiraj"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatiraj kao prenosivu"</string>
    <string name="storage_menu_format_private" msgid="3208326980027382079">"Formatiraj kao unutrašnju"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Prenesi podatke"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Zaboraviti"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Postavi"</string>
    <string name="storage_menu_explore" msgid="3048031115521594488">"Istraži"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Oslobodite prostor"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Upravljajte pohranom"</string>
    <string name="keywords_storage_menu_free" msgid="2275406357317597106">"brisanje, pohrana"</string>
    <string name="storage_title_usb" msgid="1332488715547400452">"Veza s računarom preko USB-a"</string>
    <string name="usb_connection_category" msgid="2288543238378907242">"Poveži kao"</string>
    <string name="usb_mtp_title" msgid="9068009584556422314">"Medijski uređaj (MTP)"</string>
    <string name="usb_mtp_summary" msgid="6293240861011560842">"Omogućava prenošenje medijskih fajlova u Windows ili korištenje Android File Transfer aplikacije za Mac (pogledajte www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="4496529268189091846">"Kamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="8382539472311655671">"Omogućava vam da prenesete fotografije pomoću softvera fotoaparata i da prenesete sve fajlove na računare koji ne podržavaju MTP"</string>
    <string name="usb_midi_title" msgid="1139558846427981761">"MIDI"</string>
    <string name="usb_midi_summary" msgid="1842457325845863840">"Omogućava da MIDI omogućene aplikacije rade preko USB-a sa MIDI softverom na vašem računaru."</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Drugi korisnici"</string>
    <string name="storage_internal_title" msgid="3265098802217660829">"Uređaj za memoriju"</string>
    <string name="storage_external_title" msgid="8984075540312137135">"Prenosiva memorija"</string>
    <string name="storage_volume_summary" msgid="7087627975196777994">"<xliff:g id="USED">%1$s</xliff:g> se koristi od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<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="5031288167242496837">"Se koristi od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="283558499413754323">"Ukupno iskorišteno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> je priključen"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Nije se mogao montirati <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je sigurno izbačen"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> se ne može sigurno izbaciti"</string>
    <string name="storage_format_success" msgid="3028114521294256851">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je formatiran"</string>
    <string name="storage_format_failure" msgid="2042691589726261987">"Ne može se formatirati <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Promjena naziva pohrane"</string>
    <string name="storage_dialog_unmounted" msgid="1187960789775910051">"Ovaj uređaj (<xliff:g id="NAME_0">^1</xliff:g>) je uspješno uklonjen, ali je i dalje dostupan. \n\nDa biste koristili uređaj <xliff:g id="NAME_1">^1</xliff:g>, prvo ga morate priključiti."</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Ovaj <xliff:g id="NAME_0">^1</xliff:g> je oštećen. \n\nDa biste koristili ovaj <xliff:g id="NAME_1">^1</xliff:g>, najprije ga morate postaviti."</string>
    <string name="storage_dialog_unsupported" msgid="7787241928013470089">"Ovaj uređaj ne podržava <xliff:g id="NAME_0">^1</xliff:g>. \n\n Da biste koristili <xliff:g id="NAME_1">^1</xliff:g> s ovim uređajem, najprije ga morate postaviti."</string>
    <string name="storage_internal_format_details" msgid="8922023528848861812">"Nakon formatiranja, možete koristiti ovu <xliff:g id="NAME_0">^1</xliff:g> u drugim uređajima. \n\n Svi podaci sa ove <xliff:g id="NAME_1">^1</xliff:g> će biti izbrisani. Razmislite prvo o kreiranju sigurnosne kopije \n\n"<b>" Rezervne kopije za Fotografije i druge medije "</b>\n" Premjestite multimedijalne fajlove u alternativne skladištenje na ovom uređaju, ili ih prenesete na računalo pomoću USB kabla. \n\n"<b>" Sigurnosne kopije za aplikacije"</b>\n" Sve aplikacije pohranjene na ovom <xliff:g id="NAME_6">^1</xliff:g> će biti deinstalirane i njihovi podaci će biti izbrisani. Da bi ove aplikacije sačuvali, premjestite ih u alternativne memorije na ovom uređaju."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Kada izbacite ovaj uređaj (<xliff:g id="NAME_0">^1</xliff:g>), aplikacije pohranjene na njemu će prestati radit, a medijski fajlovi pohranjeni na njemu neće biti dostupni dok ga ponovo ne umetnete."</b>" \n\nUređaj <xliff:g id="NAME_1">^1</xliff:g> je formatiran tako da funkcionira samo na ovom uređaju. Neće funkcionirati na bilo kojem drugom uređaju."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Da biste koristili aplikacije, slike ili podatke koje ovaj uređaj (<xliff:g id="NAME">^1</xliff:g>) sadrži, ponovo ga umetnite. \n\nUmjesto toga, možete odabrati da zaboravite ovu memoriju ukoliko uređaj nije dostupan \n\nAko odaberete da zaboravite memoriju, svi podaci koje uređaj sadrži će zauvijek biti izgubljeni \n\nAplikacije možete kasnije ponovo instalirati, ali njihovi podaci pohranjeni na ovom uređaju će biti izgubljeni."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Želite li zaboraviti uređaj <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Sve aplikacije, fotografije i podaci pohranjeni na ovom <xliff:g id="NAME">^1</xliff:g> bit će trajno izgubljeni."</string>
    <string name="storage_detail_apps" msgid="5055911985540355324">"Aplikacije"</string>
    <string name="storage_detail_images" msgid="6003883845718804371">"Slike"</string>
    <string name="storage_detail_videos" msgid="9079894412680404208">"Video zapisi"</string>
    <string name="storage_detail_audio" msgid="234272983148223114">"Audio fajlovi"</string>
    <string name="storage_detail_cached" msgid="4066364341463331199">"Keširani podaci"</string>
    <string name="storage_detail_other" msgid="3821329310612285961">"Ostalo"</string>
    <string name="storage_detail_system" msgid="3797439069473271732">"Sistem"</string>
    <string name="storage_detail_explore" msgid="13782374784415466">"Istraži korisnika <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="3359851869961609901">"Ostalo uključuje dijeljene fajlove koji su sačuvani pomoću aplikacija, fajlove koji su preuzeti s interneta ili Bluetootha, fajlove za Android uređaje i tako dalje. \n\nDa vidite vidljivi sadržaj ovog uređaja, <xliff:g id="NAME">^1</xliff:g>, dodirnite Istraži."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sistem obuhvata fajlove koji se koriste za pokretanje verzije Androida <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_detail_dialog_user" msgid="1691219071007313226">"Moguće je da je <xliff:g id="USER_0">^1</xliff:g> sačuvao/la fotografije, muziku, aplikacije ili druge podatke koristeći <xliff:g id="SIZE">^2</xliff:g> prostora za pohranu. \n\nDa vidite detalje, prebacite se na korisnika <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="9036374223934708619">"Podesite uređaj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="6540132491909241713">"Koristiti kao prijenosnu memoriju"</string>
    <string name="storage_wizard_init_external_summary" msgid="5807552934494462984">"Za premještanje fotografija i drugih medija s jednog uređaja na drugi."</string>
    <string name="storage_wizard_init_internal_title" msgid="3256355049992147270">"Koristi kao unutrašnju pohranu"</string>
    <string name="storage_wizard_init_internal_summary" msgid="2283798331883929674">"Za memorisanje bilo čega samo na ovaj uređaj uključujući aplikacije i fotografije. Zahtijeva formatiranje koje sprečavaju da radi sa drugim uređajima."</string>
    <string name="storage_wizard_format_confirm_title" msgid="4898014527956178762">"Formatirajte kao unutr. pohranu"</string>
    <string name="storage_wizard_format_confirm_body" msgid="5514665245241830772">"To zahtijeva da <xliff:g id="NAME_0">^1</xliff:g> bude formatirana da bi bila sigurna.\n\nNakon formatiranja, ova <xliff:g id="NAME_1">^1</xliff:g> će raditi samo na ovom uređaju. \n\n"<b>"Formatiranje briše sve podatke koji se trenutno na njoj nalaze <xliff:g id="NAME_2">^1</xliff:g>."</b>" Da biste izbjegli gubljenje podataka, razmotrite kreiranje sigurnosne kopije."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="649252654496577680">"Formatirajte kao pren. memoriju"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="6219883780307218266">"Ovo zahtijeva da se <xliff:g id="NAME_0">^1</xliff:g> formatira. \n\n"<b>"Formatiranjem se brišu svi podaci trenutno pohranjeni na uređaju <xliff:g id="NAME_1">^1</xliff:g>."</b>" Da ne biste izgubili podatke, razmislite o kreiranju sigurnosne kopije."</string>
    <string name="storage_wizard_format_confirm_next" msgid="4412063054982084056">"Izbriši i formatiraj"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatiranje <xliff:g id="NAME">^1</xliff:g>..."</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Nemojte uklanjati pohranu <xliff:g id="NAME">^1</xliff:g> dok se formatira."</string>
    <string name="storage_wizard_migrate_title" msgid="3013711737005104623">"Premjestite pod. u novu memoriju"</string>
    <string name="storage_wizard_migrate_body" msgid="1630853797296198275">"Možete premjestiti slike, fajlove i neke aplikacije na novi uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nPremještanje traje otprilike <xliff:g id="TIME">^2</xliff:g> te će osloboditi <xliff:g id="SIZE">^3</xliff:g> unutrašnje pohrane. Neke aplikacije neće funkcionirati dok je ovo u toku."</string>
    <string name="storage_wizard_migrate_now" msgid="175023718337037181">"Premjesti sada"</string>
    <string name="storage_wizard_migrate_later" msgid="6573789572520980112">"Premjesti kasnije"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="255346780598924540">"Premjesti podatke sada"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="5039938578355576124"><b>"Premještanje traje oko <xliff:g id="TIME">^1</xliff:g>. To će osloboditi <xliff:g id="SIZE">^2</xliff:g> na <xliff:g id="NAME">^3</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="217478540562501692">"Premjesti"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="462238335086734131">"Podaci se premještaju..."</string>
    <string name="storage_wizard_migrate_details" msgid="7474061662976940407">"Za vrijeme premještanja: \n• Nemojte uklanjati uređaj <xliff:g id="NAME">^1</xliff:g>. \n• Neke aplikacije neće funkcionirati ispravno. \n• Uređaj treba biti napunjen."</string>
    <string name="storage_wizard_ready_title" msgid="3093468548660255543">"Uređaj <xliff:g id="NAME">^1</xliff:g> je spreman za korištenje"</string>
    <string name="storage_wizard_ready_external_body" msgid="45040717412844114">"Uređaj <xliff:g id="NAME">^1</xliff:g> je spreman za korištenje sa slikama i drugim medijima."</string>
    <string name="storage_wizard_ready_internal_body" msgid="7734817996475607447">"Novi uređaj (<xliff:g id="NAME">^1</xliff:g>) funkcionira. \n\nDa biste premjestili slike, fajlove i podatke aplikacija na ovaj uređaj, idite na Postavke &gt; Memorija."</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Premjesti <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Premještanje <xliff:g id="APP">^1</xliff:g> i njenih podataka na <xliff:g id="NAME_0">^2</xliff:g> će trajati samo nekoliko trenutaka. Nećete biti u mogućnosti koristiti aplikacije sve dok se ne završi premještanje. \n\n Nemojte uklanjati <xliff:g id="NAME_1">^2</xliff:g> tokom premještanja."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Da prebacite podatke, morate otključati korisnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Premješta se <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Nemojte uklanjati <xliff:g id="NAME">^1</xliff:g> tokom premještanja. Aplikacija \n\n <xliff:g id="APP">^2</xliff:g> na ovom uređaju neće biti dostupna sve dok se ne završi premještanje."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="3494022998599718937">"Poništi premještanje"</string>
    <string name="storage_wizard_slow_body" msgid="8293565076885232029">"Čini se da je <xliff:g id="NAME_0">^1</xliff:g> spora. \n\n Možete nastaviti, ali aplikacije koje su premještene na ovu lokaciju mogu zastajkivati te prijenos podataka može dugo trajati. \n\n Razmislite o korištenju brže<xliff:g id="NAME_1">^1</xliff:g> za bolje performanse."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Kako ćete koristiti pohranu <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="1884468440013151482">"Koristi kao dodatnu pohranu na tabletu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="2907833056467441047">"Samo za aplikacije, fajlove i medije na ovom tabletu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="3278694259614995649">"Pohrana na tabletu"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="5941952998075252284">"Koristi kao dodatnu pohranu na telefonu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="3022584310096954875">"Samo za aplikacije, fajlove i medije na ovom telefonu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="5645732875040797464">"Pohrana na telefonu"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Ili"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="8129096036551264207">"Koristi kao prijenosnu pohranu"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="6436419488235871823">"Za prenošenje fajlova i medija s jednog uređaja na drugi"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="781928899530539860">"Prenosiva pohrana"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Postavi kasnije"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formatirati ovu pohranu <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Da biste pohranili aplikacije, fajlove i medije, potrebno je formatirati uređaj <xliff:g id="NAME_0">^1</xliff:g>. \n\nFormatiranjem se potpuno briše postojeći sadržaj pohrane <xliff:g id="NAME_1">^2</xliff:g>. Da ne biste izgubili sadržaj, napravite sigurnosnu kopiju na drugu pohranu <xliff:g id="NAME_2">^3</xliff:g> ili uređaj."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Format. pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Premjestiti sadržaj na: <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4541523202790415721">"Fajlove, medije i određene aplikacije možete premjestiti na uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nTime ćete osloboditi <xliff:g id="SIZE">^2</xliff:g> pohrane na tabletu što bi trebalo trajati oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="809730501314645325">"Fajlove, medije i određene aplikacije možete premjestiti na uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nTime ćete osloboditi <xliff:g id="SIZE">^2</xliff:g> pohrane na telefonu što bi trebalo trajati oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Tokom premještanja:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Nemojte uklanjati pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Neke aplikacije neće raditi"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="6111770421449869539">"Tablet treba biti napunjen"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="8826915870192535008">"Telefon treba biti napunjen"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Premjesti sadržaj"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Premjesti sadržaj kasnije"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Premještanje sadržaja…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Spora pohrana <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"I dalje možete koristiti uređaj <xliff:g id="NAME_0">^1</xliff:g>, ali može biti spor. \n\nAplikacije pohranjene na uređaju za pohranu <xliff:g id="NAME_1">^2</xliff:g> možda neće raditi ispravno, a prijenos sadržaja može dugo trajati. \n\nPokušajte koristiti brži uređaj za pohranu <xliff:g id="NAME_2">^3</xliff:g> ili koristite ovaj uređaj <xliff:g id="NAME_3">^4</xliff:g> kao prenosivu pohranu."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Počni ispočetka"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Nastavi"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="3896836008684280905">"Sadržaj možete premjestiti na uređaj za pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="5710665992219332454">"Da premjestite sadržaj na uređaj za pohranu <xliff:g id="NAME">^1</xliff:g>, idite u "<b>"Postavke &gt; Pohrana"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1269878056598666852">"Sadržaj je premješten na uređaj za pohranu <xliff:g id="NAME_0">^1</xliff:g>. \n\nDa upravljate uređajem za pohranu <xliff:g id="NAME_1">^2</xliff:g>, idite u "<b>"Postavke &gt; Pohrana"</b>"."</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Status baterije"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nivo napunjenosti baterije"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN-ovi"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Uredi pristupnu tačku"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nije postavljeno"</string>
    <string name="apn_name" msgid="6677695784108157953">"Naziv"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proksi"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Priključak"</string>
    <string name="apn_user" msgid="5831763936428279228">"Korisničko ime"</string>
    <string name="apn_password" msgid="7435086635953953029">"Lozinka"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS proksi"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS priključak"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Vrsta autentifikacije"</string>
    <string name="apn_auth_type_none" msgid="6845031410929644238">"Ništa"</string>
    <string name="apn_auth_type_pap" msgid="9003475621032514182">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3587713509473187621">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="6852124741245095775">"PAP ili CHAP"</string>
    <string name="apn_type" msgid="1835573305077788773">"Vrsta APN-a"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol APN-a"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol APN-a za roming"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Omogući/onemogući APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN omogućen"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN onemogućen"</string>
    <string name="bearer" msgid="3231443241639159358">"Nosilac"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO vrsta"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO vrijednost"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Izbriši APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Novi APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Sačuvaj"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Otkaži"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Polje Ime ne može ostati prazno."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Naziv pristupne tačke ne može biti prazan."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC polje mora imati 3 cifre."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC polje mora imati 2 ili 3 cifre."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operater ne dozvoljava dodavanje APN-a tipa %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Vraćanje zadanih postavki za APN."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Vrati na zadano"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Vraćanje zadanih postavki za APN je završeno."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Opcije vraćanja na zadano"</string>
    <string name="reset_dashboard_summary" msgid="4390780188264852956">"Mreža, aplikacije ili uređaj se mogu vratiti na zadano"</string>
    <string name="reset_dashboard_summary_onlyApps" msgid="3304252260039419584">"Aplikacije se mogu vratiti na zadano"</string>
    <string name="reset_network_title" msgid="1395494440355807616">"Vrati WiFi, mobilnu i Bluetooth vezu na zadano"</string>
    <string name="reset_network_desc" msgid="1112523764899788246">"Sve postavke mreže vratit će se na zadano, uključujući:\n\n"<li>"WiFi"</li>\n<li>"Prijenos podataka na mobilnoj mreži"</li>\n<li>"Bluetooth"</li></string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Izbriši"</string>
    <string name="reset_esim_title" msgid="6152167073280852849">"Izbriši preuzete SIM-ove"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Ovim se neće otkazati paketi mobilnih usluga. Da preuzmete zamjenske SIM-ove, kontaktirajte svog mobilnog operatera."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Vrati postavke na zadano"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Vratiti sve postavke mreže na zadano? Ovu radnju ne možete poništiti."</string>
    <string name="reset_network_final_desc_esim" msgid="8342882682282693844">"Vratiti sve postavke mreže na zadano i izbrisati preuzete SIM-ove? Ovu radnju ne možete poništiti."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Vrati postavke na zadano"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Vratiti na zadano?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Ponovno postavljanje mreže nije dostupno za ovog korisnika"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Postavke mreže vraćene su na zadano"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Nije moguće izbrisati SIM-ove"</string>
    <string name="reset_esim_error_msg" msgid="4441504470684307370">"Preuzete SIM-ove nije moguće izbrisati zbog greške.\n\nPonovo pokrenite uređaj i pokušajte ponovo."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Izbriši sve podatke (vraćanje na fabričke postavke)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Izbriši sve podatke"</string>
    <string name="main_clear_desc" product="tablet" msgid="1651178880680056849">"Ovim će se u potpunosti izbrisati svi podaci "<b>"unutrašnje pohrane"</b>" tableta, uključujući:\n\n"<li>"vaš Google račun"</li>\n<li>"podatke i postavke sistema i aplikacija"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="main_clear_desc" product="default" msgid="6984348811887162647">"Ovim će se potpuno izbrisati svi podaci "<b>"unutrašnje pohrane"</b>" telefona, uključujući:\n\n"<li>"vaš Google račun"</li>\n<li>"podatke i postavke sistema i aplikacija"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="main_clear_accounts" product="default" msgid="7675859115108318537">\n\n"Trenutno ste prijavljeni na sljedećim računima:\n"</string>
    <string name="main_clear_other_users_present" product="default" msgid="2672976674798019077">\n\n"Drugi korisnici su prisutni na ovom uređaju.\n"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"muziku"</li>\n<li>"fotografije"</li>\n<li>"ostale korisničke podatke"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM-ove"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Ovim se neće otkazati vaš plan usluga mobilnog operatera."</string>
    <string name="main_clear_desc_erase_external_storage" product="nosdcard" msgid="4441604184663452046">\n\n"Da obrišete muziku, slike i druge korisničke podatke, potrebno je potpuno izbrisati podatke s "<b>"USB pohrane"</b>"."</string>
    <string name="main_clear_desc_erase_external_storage" product="default" msgid="1498514970618215728">\n\n"Da obrišete muziku, slike i druge korisničke podatke, potrebno je potpuno izbrisati podatke sa "<b>"SD kartice"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="2182181846128639635">"Izbriši USB pohranu"</string>
    <string name="erase_external_storage" product="default" msgid="2610056855012660451">"Izbriši SD karticu"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="6358699244894944843">"Izbrišite sve podatke na unutrašnjoj USB pohrani, poput muzike ili fotografija"</string>
    <string name="erase_external_storage_description" product="default" msgid="3367779850546310380">"Izbrišite sve podatke na SD kartici, poput muzike ili fotografija"</string>
    <string name="main_clear_button_text" product="tablet" msgid="6246087475569640671">"Izbriši sve podatke"</string>
    <string name="main_clear_button_text" product="default" msgid="6246087475569640671">"Izbriši sve podatke"</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Izbrisat će se svi vaši lični podaci i preuzete aplikacije. Ne možete poništiti ovu radnju."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Izbrisat će se svi vaši lični podaci, uključujući preuzete aplikacije i SIM-ove. Ne možete poništiti ovu radnju."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Potpuno izbrisati sve podatke?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Vraćanje na fabričke postavke nije dostupno za ovog korisnika"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Brisanje"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Pričekajte…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Postavke poziva"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Postavite govornu poštu, prosljeđivanje poziva, poziv na čekanju, ID pozivaoca"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Povezivanje mobitela USB-om"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Prijenosna pristupna tačka"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Dijeljenje Bluetooth veze"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Povezivanje putem mobitela"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Pristupna tačka i povezivanje putem mobitela"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Pristupna tačka je uključena, veza se dijeli"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Pristupna tačka je uključena"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Povezivanje putem mobitela"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Dok je upaljena Ušteda podataka nije moguće povezati uređaj niti koristiti prijenosne pristupne tačke"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Samo pristupna tačka"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Samo USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Samo Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Samo Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Pristupna tačka, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Pristupna tačka, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Pristupna tačka, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Pristupna tačka, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Pristupna tačka, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Pristupna tačka, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Pristupna tačka, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internet se ne dijeli s drugim uređajima"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Povezivanje putem mobitela"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Ne koristi WiFi pristupnu tačku"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Dijeljenje interneta isključivo putem USB-a"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Dijeljenje interneta isključivo putem Bluetootha"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Dijeljenje interneta isključivo putem Etherneta"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Dijeljenje interneta isključivo putem USB-a i Bluetootha"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Dijeljenje interneta isključivo putem USB-a i Etherneta"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Dijeljenje interneta isključivo putem Bluetootha i Etherneta"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Dijeljenje interneta isključivo putem USB-a, Bluetootha i Etherneta"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Povezivanje mobitela putem USB-a"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3168636595109044213">"Dijeljenje internetske veze telefona putem USB-a"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="1749659335004856576">"Dijeljenje internetske veze tableta putem USB-a"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Povezivanje mobitela putem Bluetootha"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="2023654677593885805">"Dijeljenje internetske veze tableta putem Bluetootha"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="4322810060538179348">"Dijeljenje internetske veze telefona putem Bluetootha"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6941934844527406581">"Dijeljenje internetske veze uređaja <xliff:g id="DEVICE_NAME">%1$d</xliff:g> putem Bluetootha"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="5292358672240161566">"Nije se moguće povezati sa više od <xliff:g id="MAXCONNECTION">%1$d</xliff:g> uređaja."</string>
    <string name="bluetooth_untether_blank" msgid="5087548945727762308">"Prestat će se dijeliti veza s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Povezivanje putem mobitela za Ethernet"</string>
    <string name="ethernet_tethering_subtext" product="default" msgid="5998100693350351694">"Dijeljenje internetske veze telefona putem etherneta"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Koristite pristupnu tačku i povezivanje putem mobitela za pružanje interneta drugim uređajima putem veze za prijenos podataka na mobilnoj mreži. Aplikacije također mogu kreirati pristupne tačke za dijeljenje sadržaja s uređajima u blizini."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Koristite pristupnu tačku i povezivanje putem mobitela za pružanje interneta drugim uređajima putem WiFi mreže ili veze za prijenos podataka na mobilnoj mreži. Aplikacije također mogu kreirati pristupne tačke za dijeljenje sadržaja s uređajima u blizini."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pomoć"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilna mreža"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Paket mobilne usluge"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikacija za SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Promijeniti aplikaciju za SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Koristiti <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Koristiti <xliff:g id="NEW_APP">%s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="network_scorer_picker_title" msgid="2022922801936206195">"Ocjenjivač mreže"</string>
    <string name="network_scorer_picker_none_preference" msgid="8894034333043177807">"Ništa"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Promijeniti WiFi asistenta?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Želite li koristiti aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Koristiti <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje vašim mrežnim vezama?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Nepoznati SIM operater"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> nema poznatu web lokaciju za omogućavanje upotrebe"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Umetnite SIM karticu i ponovo pokrenite uređaj"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Povežite se na Internet"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavni zahtjevi za lokaciju"</string>
    <string name="location_recent_location_requests_see_all" msgid="7918405176741692524">"Prikaži sve"</string>
    <string name="location_category_location_services" msgid="8163798686832434284">"Usluge lokacije"</string>
    <string name="location_title" msgid="5819154746934945021">"Moja lokacija"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za poslovni profil"</string>
    <string name="location_app_level_permissions" msgid="45436724900423656">"Pristup aplikacije lokaciji"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokacija je isključena"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="8286873148858526214">
      <item quantity="one"> Pristup lokaciji ima sljedeći broj aplikacija: <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g></item>
      <item quantity="few"> Pristup lokaciji ima sljedeći broj aplikacija: <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g></item>
      <item quantity="other"> Pristup lokaciji ima sljedeći broj aplikacija: <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g></item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="7880996987927703141">"Nedavni pristup lokaciji"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Prikaži detalje"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Nijedna aplikacija nije zahtijevala utvrđivanje lokacije u posljednje vrijeme"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Nijedna aplikacija nije nedavno pristupila lokaciji"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Visoka potrošnja baterije"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Niska potrošnja baterije"</string>
    <string name="location_scanning_screen_title" msgid="2346125609614249968">"Skeniranje WiFi-ja i Bluetootha"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Skeniranje WiFi-ja"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Dozvolite aplikacijama i uslugama da skeniraju WiFi mreže u svakom trenutku, čak i kada je WiFi mreža isključena. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Skeniranje Bluetootha"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Dozvolite aplikacijama i uslugama da skeniraju uređaje u blizini u svakom trenutku, čak i kada je Bluetooth isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="managed_profile_location_services" msgid="8172092734138341880">"Usluge lokacije za posao"</string>
    <string name="location_time_zone_detection_screen_title" msgid="8396625087466311625">"Otkrivanje vremenske zone pomoću lokacije"</string>
    <string name="location_time_zone_detection_enabled_title" msgid="1195178875042989835">"Otkrivanje vremenske zone pomoću lokacije"</string>
    <string name="location_time_zone_detection_enabled_description" msgid="1064716900984397624">"Omogućava korištenje lokacije uređaja radi određivanja trenutne vremenske zone. Ostale postavke lokacije kao što je skeniranje WiFi mreže mogu uticati na preciznost otkrivanja vremenske zone."</string>
    <string name="location_time_zone_detection_on" msgid="5514817179120761597">"Uključeno"</string>
    <string name="location_time_zone_detection_off" msgid="192427076195667079">"Isključeno"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="8067073548483627695">"Automatsko određivanje vremenske zone je onemogućeno"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Otkrivanje vremenske zone pomoću lokacije je onemogućeno"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Otkrivanje vremenske zone pomoću lokacije nije podržano"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Promjene otkrivanja vremenske zone pomoću lokacije nisu dozvoljene"</string>
    <string name="location_network_based" msgid="5247042890080021887">"Lokacija WiFi i mobilne mreže"</string>
    <string name="location_neighborhood_level" msgid="3668890550358558267">"Omogućava da aplikacije koriste Googleovu uslugu lokacije kako bi brže procijenile vašu lokaciju. Anonimni podaci o lokaciji se prikupljaju i šalju Googleu."</string>
    <string name="location_neighborhood_level_wifi" msgid="6227393490651891977">"Lokacija utvrđena putem WiFi mreže"</string>
    <string name="location_gps" msgid="8783616672454701134">"GPS sateliti"</string>
    <string name="location_street_level" product="tablet" msgid="865953107414742784">"Dopustite aplikacijama da koriste GPS na tabletu za određivanje vaše lokacije"</string>
    <string name="location_street_level" product="default" msgid="3813836654645896185">"Dopustite aplikacijama da koriste GPS na telefonu za određivanje vaše lokacije"</string>
    <string name="assisted_gps" msgid="1714546606018821498">"Koristi potpomognuti GPS"</string>
    <string name="assisted_gps_enabled" msgid="6220188450779319248">"Koristi server za pomoć GPS-u (uklonite oznaku kako biste smanjili korištenje mreže)"</string>
    <string name="assisted_gps_disabled" msgid="1062496503892849">"Koristi server za pomoć GPS-u (uklonite oznaku kako biste poboljšali performanse GPS-a)"</string>
    <string name="use_location_title" msgid="1345594777162897654">"Lokacija i Google pretraživanje"</string>
    <string name="use_location_summary" msgid="377322574549729921">"Dopustite da Google koristi vašu lokaciju radi poboljšavanja rezultata pretraživanja i drugih usluga"</string>
    <string name="location_access_title" msgid="4052667453826272040">"Pristup mojoj lokaciji"</string>
    <string name="location_access_summary" msgid="8634100005481578143">"Dopustite aplikacijama koje su zatražile vaše odobrenje da koriste informacije o vašoj lokaciji"</string>
    <string name="location_sources_heading" msgid="6126965815860570524">"Izvori lokacije"</string>
    <string name="about_settings" product="tablet" msgid="2888705054709289693">"O tabletu"</string>
    <string name="about_settings" product="default" msgid="4038626127378127613">"O telefonu"</string>
    <string name="about_settings" product="device" msgid="9012888717090302815">"O uređaju"</string>
    <string name="about_settings" product="emulator" msgid="2516560858771320366">"O emuliranom uređaju"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Prikaži pravne informacije, status, verziju softvera"</string>
    <string name="legal_information" msgid="7509900979811934843">"Pravne informacije"</string>
    <string name="contributors_title" msgid="7965640251547037965">"Saradnici"</string>
    <string name="manual" msgid="3651593989906084868">"Ručno"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulatorne oznake"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Priručnik za sigurnost i propise"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autorska prava"</string>
    <string name="license_title" msgid="8745742085916617540">"Licenca"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licence za ažuriranje sistema Google Playa"</string>
    <string name="terms_title" msgid="2071742973672326073">"Odredbe i uslovi"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Sistemske WebView licence"</string>
    <string name="wallpaper_attributions" msgid="3080339190260272255">"Pozadinske slike"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Pružaoci satelitskih slika:\n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Ručno"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Došlo je do problema sa učitavanjem priručnika."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licence trećih strana"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Pojavio se problem s učitavanjem licenci."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Učitavanje…"</string>
    <string name="settings_safetylegal_title" msgid="1334501164265709288">"Sigurnosne informacije"</string>
    <string name="settings_safetylegal_activity_title" msgid="2218587051061093358">"Sigurnosne informacije"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="6571695168138207587">"Nemate vezu za prijenos podataka. Za trenutni prikaz tih informacija idite na %s s bilo kojeg računara koji je povezan na internet."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Učitavanje…"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="7587198092214670356">"Postavite zaključavanje ekrana"</string>
    <string name="lockpassword_choose_your_password_message" msgid="4474728476383676731">"Postavite lozinku radi sigurnosti"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Da koristite otisak prsta, postavite lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Da koristite otisak prsta, postavite uzorak"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Postavite PIN radi sigurnosti"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Da koristite otisak prsta, postavite PIN"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="5815780503576680412">"Postavite uzorak radi sigurnosti"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Ponovo unesite lozinku"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Unesite radnu lozinku"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potvrdite uzorak"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Unesite radni uzorak"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Ponovo unesite PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Unesite radni PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Lozinke se ne podudaraju"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN-ovi se ne podudaraju"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Ponovo nacrtajte uzorak"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Vrste otključavanja"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Lozinka je postavljena"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN je postavljen"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Uzorak je postavljen"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="5359649947642749079">"Za otključavanje licem postavite lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="9220480399170764760">"Za otključavanje licem, postavite uzorak"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="2285401208117502869">"Za otključavanje licem, postavite PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="9091792721166354172">"Da koristite biometriju, postavite lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4949972592985176347">"Da koristite biometriju, postavite uzorak"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="4215367936503271941">"Da koristite biometriju, postavite PIN"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Zaboravili ste lozinku?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Zaboravili ste uzorak?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Zaboravili ste PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Unesite uzorak uređaja da nastavite"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Unesite PIN uređaja da nastavite"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Za nastavak, unesite lozinku uređaja."</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Za nastavak, unesite radni uzorak"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Unesite radni PIN da nastavite"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Za nastavak, unesite radnu lozinku."</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Za dodatnu sigurnost, unesite uzorak uređaja"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Za dodatnu sigurnost, unesite PIN uređaja"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Za dodatnu sigurnost, unesite lozinku uređaja"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Za dodatnu sigurnost, unesite radni uzorak"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Za dodatnu sigurnost, unesite radni PIN"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Za dodatnu sigurnost, unesite radnu lozinku"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6351784282865851482">"Vaš telefon je vraćen na fabričke postavke. Da koristite telefon, unesite prethodni obrazac."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="2128795640346033349">"Vaš telefon je vraćen na fabričke postavke. Da koristite telefon, unesite prethodni PIN."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="4031863562975125016">"Vaš telefon je vraćen na fabričke postavke. Da koristite telefon, unesite prethodnu lozinku."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Potvrdite obrazac"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Potvrdite PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Potvrdite lozinku"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Pogrešan PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Pogrešna lozinka"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Pogrešan uzorak"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Sigurnost uređaja"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Promijeni uzorak za otključavanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Promijeni PIN za otključavanje"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Nacrtajte uzorak za otključavanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Pritisnite Meni za pomoć."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Podignite prst kada završite"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Povežite najmanje <xliff:g id="NUMBER">%d</xliff:g> tačke. Pokušajte ponovo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Uzorak snimljen"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Ponovo nacrtajte uzorak da potvrdite"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Novi uzorak za otključavanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potvrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Nacrtaj ponovo"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Obriši"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Nastavi"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Uzorak za otključavanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Zahtijevaj uzorak"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Mora se nacrtati uzorak za otključavanje ekrana"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Učini uzorak vidljivim"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Neka uzorak profila bude vidljiv"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibracija na dodir"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Dugme za napajanje zaključava"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Osim kada ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> drži otključanim"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Postavi uzorak otključavanja"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Promijeni uzorak za otključavanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kako nacrtati uzorak za otključavanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Previše pogrešnih pokušaja. Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikacija nije instalirana na vašem telefonu."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Sigurnost radnog profila"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zaključavanje ekrana radnog profila"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Koristi jedno zaključavanje za radni profil i ekran uređaja"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Želite li koristiti jedno zaključavanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Uređaj će koristiti zaključavanje ekrana vašeg radnog profila. Pravila za rad će se primjenjivati za oba tipa zaključavanja."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Zaključavanje vašeg radnog profila ne ispunjava sigurnosne zahtjeve vaše organizacije. Možete koristiti isto zaključavanje za ekran uređaja i radnog profila, ali važit će sve postavke zaključavanja radnog profila."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Isto kao i zaključavanje ekrana uređaja"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Upravljaj aplikacijama"</string>
    <string name="manageapplications_settings_summary" msgid="848586372489062357">"Upravljanje instaliranim aplikacijama i uklonite ih"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informacije o aplikaciji"</string>
    <string name="applications_settings_summary" msgid="8206066893744768531">"Upravljanje aplikacijama, postavljanje prečica za brzo pokretanje"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Postavke aplikacije"</string>
    <string name="install_applications" msgid="3921609656584369901">"Nepoznati izvori"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Dopusti sve izvore aplikacija"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nedavno otvarane aplikacije"</string>
    <plurals name="see_all_apps_title" formatted="false" msgid="6864581406735745400">
      <item quantity="one">Prikaz svih aplikacija, ukupno %1$d</item>
      <item quantity="few">Prikaz svih aplikacija, ukupno %1$d</item>
      <item quantity="other">Prikaz svih aplikacija, ukupno %1$d</item>
    </plurals>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontaktirajte IT administratora"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Može vam pomoći s poništavanjem PIN-a, uzorka ili lozinke"</string>
    <string name="install_all_warning" product="tablet" msgid="7010749217925069520">"Vaši podaci na tabletu i lični podaci su više izloženi napadima aplikacija iz nepoznatih izvora. Instaliranjem aplikacija iz takvih izvora, saglasni ste da ste vi odgovorni za bilo kakvu štetu na telefonu ili gubitak podataka koji mogu nastati korištenjem tih aplikacija."</string>
    <string name="install_all_warning" product="default" msgid="652516435709047343">"Vaši podaci na telefonu i lični podaci više su izloženi napadima aplikacija iz nepoznatih izvora. Instaliranjem aplikacija iz takvih izvora, saglasni ste da ste vi odgovorni za bilo kakvu štetu na telefonu ili gubitak podataka koji mogu nastati korištenjem tih aplikacija."</string>
    <string name="install_all_warning" product="device" msgid="2348262609815354500">"Podaci s vašeg uređaja i vaši lični podaci su izloženiji napadima nepoznatih aplikacija. Instaliranjem aplikacija iz ovog izvora prihvatate odgovornost za bilo kakvu štetu na uređaju ili gubitak podataka uzrokovan njihovim korištenjem."</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Napredne postavke"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Omogućite više opcija postavki"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Informacije o aplikaciji"</string>
    <string name="storage_label" msgid="2522307545547515733">"Pohrana"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Zadano otvaranje"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Zadane vrijednosti"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilnost ekrana"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Odobrenja"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Keš memorija"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Obriši keš memoriju"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Keš memorija"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="8212425823423508096">
      <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="4828117421162495134">"Pristup je slobodan"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontrole"</string>
    <string name="force_stop" msgid="2681771622136916280">"Prisilno zaustavi"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Ukupno"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Veličina aplikacije"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikacija USB pohrane"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Korisnički podaci"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="1054860423004751290">"Podaci USB pohrane"</string>
    <string name="external_data_size_label" product="default" msgid="3370825186202856353">"SD kartica"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Deinstaliraj"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Deinstaliraj za sve korisnike"</string>
    <string name="install_text" msgid="4558333621516996473">"Instaliraj"</string>
    <string name="disable_text" msgid="5146002260857428005">"Onemogući"</string>
    <string name="enable_text" msgid="8570798764647110430">"Omogući"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Obriši pohranu"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Deinstaliraj ažuriranja"</string>
    <string name="auto_launch_enable_text" msgid="286244432074382294">"Odabrali ste zadano pokretanje ove aplikacije za neke radnje."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Odabrali ste da ovoj aplikaciji dodijelite odobrenje za kreiranje vidžeta i pristup njihovim podacima."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nisu postavljene zadane vrijednosti."</string>
    <string name="clear_activities" msgid="341345438786077236">"Obriši zadane vrijednosti"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Ova aplikacija možda nije dizajnirana za vaš ekran. Ovdje možete odrediti kako se ona prilagođava vašem ekranu."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Pitaj prilikom pokretanja"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skaliraj aplikaciju"</string>
    <string name="unknown" msgid="8192160131923461175">"Nepoznato"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Poredaj po imenu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Poredaj po veličini"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Najskorije"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Najčešće"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Prikaži pokrenute usluge"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Prikaži procese iz keš memorije"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikacija za hitne situacije"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Vrati postavke aplikacije na zadano"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Vratiti postavke aplikacije na zadano?"</string>
    <string name="reset_app_preferences_desc" msgid="6509978724602405805">"Na ovaj način će se vratiti sve postavke na zadano za:\n\n"<li>"Onemogućene aplikacije"</li>\n<li>"Obavještenja za onemogućene aplikacije"</li>\n<li>"Zadane aplikacije za radnje"</li>\n<li>"Ograničenje pozadinskih podataka za aplikacije"</li>\n<li>"Sva ograničenja za odobrenja"</li>\n\n"Nećete izgubiti podatke iz aplikacija."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Vrati aplikacije na zadano"</string>
    <string name="manage_space_text" msgid="9013414693633572277">"Upravljaj prostorom"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Odaberite opcije filtera"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Sve aplikacije"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Onemogućene aplikacije"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Preuzeto"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Pokretanje"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="5140211657134608469">"USB pohrana"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1774499644768369891">"Na SD kartici"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nije instal. za ovog korisnika"</string>
    <string name="installed" msgid="2837449358488825884">"Instalirano"</string>
    <string name="no_applications" msgid="985069304755391640">"Nema aplikacija."</string>
    <string name="internal_storage" msgid="999496851424448809">"Unutrašnja pohrana"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Ponovno izračunavanje veličine…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Izbrisati podatke aplikacija?"</string>
    <string name="clear_data_dlg_text" msgid="7870723948123690332">"Svi podaci ove aplikacije će biti trajno izbrisani. To uključuje sve fajlove, postavke, račune, baze podataka itd."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Uredu"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Otkaži"</string>
    <string name="app_not_found_dlg_title" msgid="7122106240981109930"></string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikacija nije pronađena na listi instaliranih aplikacija."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Pohrana za aplikaciju nije obrisana."</string>
    <string name="join_two_items" msgid="7893073836681382429">"<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="5301233410730513655">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="4915310659841174866">"Računanje…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nije bilo moguće izračunati veličinu paketa."</string>
    <string name="version_text" msgid="7628938665256107608">"verzija <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Premjesti"</string>
    <string name="move_app_to_internal" product="tablet" msgid="5799782476959541144">"Premjesti na tablet"</string>
    <string name="move_app_to_internal" product="default" msgid="7395498801589544372">"Premjesti na telefon"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="1145367822171576972">"Premjesti na USB pohranu"</string>
    <string name="move_app_to_sdcard" product="default" msgid="7161667212614143767">"Premjesti na SD karticu"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Druga migracija je već u toku."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nema dovoljno prostora za pohranu."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikacija ne postoji."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Lokacija instaliranja nije važeća."</string>
    <string name="system_package" msgid="7559476279008519360">"Ažuriranja sistema se ne mogu instalirati na vanjske medijume."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikaciju administratora uređaja nije moguće instalirati na vanjski medij"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Prisilno zaustaviti?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Ako prisilno zaustavite aplikaciju, moguće je da će se ponašati nepredviđeno."</string>
    <string name="app_install_location_title" msgid="8932938164156303191">"Željena lokacija za instaliranje"</string>
    <string name="app_install_location_summary" msgid="4948270795544357021">"Promijenite preferiranu lokaciju za instaliranje novih aplikacija"</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Onemogući aplikaciju"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ako onemogućite ovu aplikaciju, moguće je da Android i druge aplikacije više neće funkcionirati ispravno. Vodite računa da ovu aplikaciju ne možete izbrisati jer je unaprijed instalirana na vašem uređaju. Ako onemogućite, isključit ćete ovu aplikaciju i sakriti je na uređaju."</string>
    <string name="app_disable_notifications_dlg_title" msgid="6686569904059411780">"Isključiti obavještenja?"</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Trgovina"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detalji o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikacija je instalirana iz trgovine: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Više informacija na <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Pokrenuto"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nikad korišteno)"</string>
    <string name="no_default_apps" msgid="8966319676910104570">"Nema zadanih aplikacija."</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Korištenje pohrane"</string>
    <string name="storageuse_settings_summary" msgid="5001621552305431831">"Prikaži pohranu koju koriste aplikacije"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Ponovno pokretanje"</string>
    <string name="cached" msgid="5379485147573438201">"Keširani procesi u pozadini"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Ništa nije pokrenuto."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Pokrenula aplikacija."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Slobodno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Iskorišteno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Korisnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Uklonjen korisnik"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<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="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluge/a"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces/a i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces/a i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluge/a"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memorija uređaja"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Iskorištenost RAM-a aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Slobodno"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Iskorišteno"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Keširano"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Pokrenuta aplikacija"</string>
    <string name="no_services" msgid="3898812785511572899">"Nije aktivno"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Usluge"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesi"</string>
    <string name="service_stop" msgid="5712522600201308795">"Zaustavi"</string>
    <string name="service_manage" msgid="3896322986828332075">"Postavke"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Ovu uslugu je pokrenula njena aplikacija. Zaustavljanje može izazvati prekid rada aplikacije."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Ovu aplikaciju nije moguće zaustaviti na siguran način. Ako je zaustavite mogli biste izgubiti dio sadržaja na kome trenutno radite."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Ovo je stari aplikacijski proces ostavljen u funkciji za slučaj da zatreba. Obično nema razloga za njegovo zaustavljanje."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutno je u upotrebi. Dodirnite Postavke da kontrolirate uslugu."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Glavni proces se koristi."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Usluga <xliff:g id="COMP_NAME">%1$s</xliff:g> se koristi."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Pružalac <xliff:g id="COMP_NAME">%1$s</xliff:g> se koristi."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Zaustaviti sistemsku uslugu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="2076922609580490122">"Ako zaustavite ovu uslugu, neke funkcije tableta će možda prestati pravilno funkcionirati sve dok ne isključite i zatim ponovo uključite tablet."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="2625863973434309085">"Ako zaustavite ovu uslugu, neke funkcije telefona će možda prestati pravilno funkcionirati sve dok ne isključite i zatim ponovo uključite tablet."</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Jezici, unos i pokreti"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="8670153838520237089"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="2738661322747920463"></string>
    <string name="language_input_gesture_summary_off" msgid="1604575860215661606"></string>
    <string name="language_settings" msgid="8700174277543875046">"Jezici i unos"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nemate odobrenje za promjenu jezika na uređaju."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Jezici i unos"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Alati"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatura i načini unosa"</string>
    <string name="phone_language" msgid="5986939176239963826">"Jezici"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatska zamjena"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Ispravi pogrešno napisane riječi"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Automatsko veliko slovo"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Piši prvu riječ u rečenici velikim početnim slovom."</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatska interpunkcija"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Postavke fizičke tastature"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Pritisnite tipku za razmak dva puta kako biste umetnuli \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Prikaži lozinke"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Kratko prikazivanje znakova dok pišete"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Ovaj alat za provjeru pravopisa u mogućnosti je da prikuplja sav tekst koji upišete, uključujući lične podatke kao što su lozinke i brojevi kreditnih kartica. Alat je omogućila aplikacija <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Da li želite koristiti ovaj alat za provjeru pravopisa?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Postavke"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jezik"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastature"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Tastatura na ekranu"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard tastatura"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Tastatura na ekranu je dostupna"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Upravljajte tastaturama na ekranu"</string>
    <string name="keyboard_assistance_category" msgid="7320599809770932032">"Pomoć za tastaturu"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fizička tastatura"</string>
    <string name="show_ime" msgid="4334255501724746849">"Korištenje tastature na ekranu"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Zadržava se na ekranu dok je fizička tastatura aktivna"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Prečice tastature"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="8649760728213630156">"Prikaz dostupnih prečica"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatura i alati radnog profila"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Tastatura na ekranu za posao"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Zadano"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Brzina pokazivača"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Kontroler za igre"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Preusmjeravanje vibracije"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Pošalji vibraciju na kontroler za igre kada je povezan."</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Odaberite raspored tastature"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Postavi rasporede tastature"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Da biste izvršili prebacivanje, pritisnite kombinaciju tipki \"Control-Space\""</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Zadano"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Rasporedi tastature"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Lični rječnik"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Lični rječnik za posao"</string>
    <string name="user_dict_settings_summary" msgid="262228126041933459"></string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Dodaj u rječnik"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Više opcija"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Manje opcija"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Uredu"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Riječ:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Prečica:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Napišite riječ"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Opcionalna prečica"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Uredi riječ"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Uređivanje"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Nemate nijednu riječ u korisničkom rječniku. Da dodate riječ, dodirnite dugme Dodaj (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Za sve jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Više jezika…"</string>
    <string name="testing" msgid="6294172343766732037">"Testiranje"</string>
    <string name="testing_phone_info" product="tablet" msgid="1910768200608214456">"Informacije o tabletu"</string>
    <string name="testing_phone_info" product="default" msgid="1150527695827743906">"Informacije o telefonu"</string>
    <string name="input_methods_settings_title" msgid="7796027458321225550">"Unos teksta"</string>
    <string name="input_method" msgid="2982805181425436775">"Način unosa"</string>
    <string name="current_input_method" msgid="3471068842881330883">"Aktualna tastatura"</string>
    <string name="input_method_selector" msgid="8463209725824763600">"Birač načina unosa"</string>
    <string name="input_method_selector_show_automatically_title" msgid="6483428482089875034">"Automatski"</string>
    <string name="input_method_selector_always_show_title" msgid="2479533500357556146">"Uvijek prikaži"</string>
    <string name="input_method_selector_always_hide_title" msgid="807424180027384849">"Uvijek sakrij"</string>
    <string name="configure_input_method" msgid="8831343065130376880">"Postavite načine unosa"</string>
    <string name="input_method_settings" msgid="4177883733022569830">"Postavke"</string>
    <string name="input_method_settings_button" msgid="5145039044301426311">"Postavke"</string>
    <string name="input_methods_settings_label_format" msgid="5809693308957109022">"<xliff:g id="IME_NAME">%1$s</xliff:g> postavke"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="8940326108334307057">"Odaberite aktivne načine unosa"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="3975358507879701606">"Postavke tastature na ekranu"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fizička tastatura"</string>
    <string name="builtin_keyboard_settings_summary" msgid="4332792334499933856">"Postavke fizičke tastature"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Odaberite gadžet"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Odaberi vidžet"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Kreirati vidžet i omogućiti pristup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5694218981358874429">"Nakon što kreirate vidžet, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> može pristupiti svim podacima koje prikazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Uvijek dopusti da aplikacija <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> kreira vidžete i koristi njihove podatke"</string>
    <string name="usage_stats_label" msgid="6523644917803320085">"Statistika korištenja"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Statistika korištenja"</string>
    <string name="display_order_text" msgid="7120394778684605892">"Poredaj po:"</string>
    <string name="app_name_label" msgid="3809910527680143673">"Aplikacija"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Posljednji put korišteno"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Vrijeme korištenja"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Pristupačnost"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Postavke pristupačnosti"</string>
    <string name="accessibility_settings_summary" msgid="2195085206729325737">"Čitači ekrana, ekran, kontrole za interakciju"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Postavke za vid"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Ovaj uređaj možete prilagoditi svojim potrebama. Funkcije pristupačnosti se mogu kasnije promijeniti u Postavkama."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Promijenite veličinu fonta"</string>
    <string name="screen_reader_category_title" msgid="6195867428854871553">"Čitači ekrana"</string>
    <string name="audio_and_captions_category_title" msgid="5049122378290004050">"Zvuk i tekst na ekranu"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Prikaz"</string>
    <string name="accessibility_text_and_display_title" msgid="1398507755501334961">"Tekst i prikaz"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrole za interakciju"</string>
    <string name="accessibility_tap_assistance_title" msgid="1459944158978398532">"Pomoć u vezi s dodirima"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Kontrole sistema"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Preuzete aplikacije"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimentalno"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Oznake funkcija"</string>
    <string name="talkback_title" msgid="8756080454514251327">"Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Čitač ekrana prvenstveno za slijepe i slabovidne osobe"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Dodirnite stavke na ekranu da se naglas pročitaju"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Postavke titlova"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Uvećavanje"</string>
    <string name="accessibility_magnification_mode_title" msgid="879250866604403721">"Područje uvećavanja"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="4821458740248772054">"Odabir područja uvećavanja koja želite koristiti prilikom uvećavanja ekrana"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Cijeli ekran"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="5630032596384610913">"Dio ekrana"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="5139954486886669293">"Cijeli ekran i dio ekrana"</string>
    <string name="accessibility_magnification_area_settings_full_screen" msgid="4189574224079433280">"Povećavanje cijelog ekrana"</string>
    <string name="accessibility_magnification_area_settings_window_screen" msgid="7431401975447232976">"Uvećavanje dijela ekrana"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Prebaciti na dugme Pristupačnost?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="5291166101273060742">"Trostruki dodir za uvećavanje dijela ekrana će prouzrokovati kašnjenje unosa teksta i drugih radnji. \n\nŽelite li prebaciti na korištenje dugmeta Pristupačnost za uvećavanje?"</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Prebaci na dugme Pristupačnost"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="5750910789717343646">"Zadrži trostruki dodir za uvećavanje"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Postavke uvećavanja"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Uvećavanje trostrukim dodirom"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Uvećavanje pomoću prečice"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Uvećajte pomoću prečice i trostrukog dodira"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"O usluzi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opcije"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Uvećajte prikaz na ekranu"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Dodirnite tri puta da zumirate"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Dodirnite dugme da zumirate"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2023126829553044999">"Brzo uvećajte ekran da jasnije vidite sadržaj.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Da uvećate:&lt;/b&gt;&lt;br/&gt; 1. Koristite prečicu da pokrenete uvećavanje&lt;br/&gt; 2. Dodirnite ekran&lt;br/&gt; 3. Prevlačite s 2 prsta za kretanje po ekranu&lt;br/&gt; 4. Uhvatite s dva prsta da podesite zumiranje&lt;br/&gt; 5. Koristite prečicu da zaustavite uvećavanje&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Da privremeno uvećate:&lt;/b&gt;&lt;br/&gt; 1. Koristite prečicu da pokrenete uvećavanje&lt;br/&gt; 2. Dodirnite i držite bilo gdje na ekranu&lt;br/&gt; 3. Prevucite prstom da se krećete po ekranu&lt;br/&gt; 4. Podignite prst da zaustavite uvećavanje"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kada je uvećavanje uključeno, možete uvećavati sadržaj na ekranu.\n\n"<b>"Da zumirate"</b>", pokrenite uvećavanje, a zatim dodirnite ekran bilo gdje.\n"<ul><li>"Prevucite dva ili više prstiju za klizanje"</li>\n<li>"Uhvatite s dva ili više prstiju za podešavanje zumiranja"</li></ul>\n\n<b>"Za privremeno zumiranje"</b>" pokrenite uvećanje, a zatim dodirnite ekran bilo gdje i zadržite.\n"<ul><li>"Prevucite za kretanje po ekranu"</li>\n<li>"Podignite prst za umanjivanje"</li></ul>\n\n"Nije moguće uvećati na tastaturi ili traci za navigaciju."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Stranica <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Otvorite pomoću dugmeta za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Držite tipke za jačinu zvuka da otvorite"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Triput dodirnite ekran da otvorite"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Otvorite pokretom"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8485448068531147828">"Koristite novi pokret za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Da koristite ovu funkciju, dodirnite dugme Pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> na dnu ekrana.\n\nDa prebacujete između funkcija, dodirnite i zadržite dugme Pristupačnost."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Da koristite ovu funkciju, pritisnite i držite obje tipke za jačinu zvuka."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Da pokrenete i zaustavite uvećavanje, triput dodirnite bilo gdje na ekranu."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Da koristite ovu funkciju, prevucite s 2 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 2 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Da koristite ovu funkciju, prevucite s 3 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 3 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Da koristite funkciju pristupačnosti, prevucite s 2 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 2 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Da koristite funkciju pristupačnosti, prevucite s 3 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 3 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Razumijem"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Prečica za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Prevucite prema gore s 2 prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Prevucite prema gore s 3 prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Dodirnite dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Dodirnite dugme Pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> na dnu ekrana.\n\nDa prebacujete između funkcija, dodirnite i zadržite dugme Pristupačnost."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Prevucite s dva prsta prema gore s dna ekrana.\n\nDa prebacujete između funkcija, s dva prsta prevucite prema gore i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Prevucite s tri prsta prema gore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s tri prsta prema gore i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Držite tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"držite tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Pritisnite i zadržite obje tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Dodirnite ekran triput"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"dodirnite ekran triput"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="3081710523998838305">"Brzo dodirnite ekran 3 puta. Ova prečica može usporiti vaš uređaj."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Napredno"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Dugme Pirstupačnost podešeno je za aktiviranje usluge <xliff:g id="SERVICE">%1$s</xliff:g>. Da koristite uvećavanje, dodirnite i držite dugme Pristupačnost, zatim odaberite uvećavanje."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Pokret za pristupačnost je postavljen na <xliff:g id="SERVICE">%1$s</xliff:g>. Za korištenje uvećavanja prevucite s dva prsta prema gore s dna ekrana i zadržite. Nakon toga odaberite uvećavanje."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Prečica tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_service_title" msgid="6842883700702723355">"Usluga prečice"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Postavke prečice"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Prečica sa zaključanog ekrana"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Dozvolite da se prečica funkcije uključi sa zaključanog ekrana. Držite obje tipke za jačinu zvuka nekoliko sekundi."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst visokog kontrasta"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatsko ažurir. uvećav. ekrana"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ažurira uvećavanje ekrana kod prelaza aplikacija"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Dugme uklj./isklj. prekida poziv"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Veliki pokazivač miša"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Ukloni animacije"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Mono zvuk"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kombiniranje kanala prilikom reprodukcije zvuka"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Balans zvuka"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Lijevo"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Desno"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Zadano"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekundi"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekundi"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuta"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minute"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Vrijeme za poduzimanje radnje za pristupačnost"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Vrijeme za poduzimanje radnje"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="5283566580551714506">"Odaberite koliko dugo želite da se prikazuju poruke koje od vas zahtijevaju da poduzmete radnju, a koje će biti vidljive samo privremeno.\n\nOvu postavku ne podržavaju sve aplikacije."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Odgoda za dodirivanje i držanje"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inverzija boja"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Koristi inverziju boja"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="6955835010409034745">"Inverzija boja mijenja svijetli ekran u tamni.&lt;br/&gt;&lt;br/&gt; Napomena: &lt;ol&gt; &lt;li&gt; Inverzija boja također mijenja tamne ekrane u svijetle.&lt;/li&gt; &lt;li&gt; Promijenit će se boje medijskih fajlova i slika.&lt;/li&gt; &lt;li&gt; Tamna tema se može koristiti za prikazivanje tamne pozadine. Tamna tema funkcionira u podržanim aplikacijama. Inverzija boja funkcionira u svim aplikacijama.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatski klik (vrijeme zadržavanja)"</string>
    <string name="accessibility_autoclick_description" msgid="6827042379062255307">"Automatski klik funkcionira s povezanim mišem. Možete postaviti da kursor miša automatski klikne kada se prestane kretati određeno vrijeme."</string>
    <string name="accessibility_autoclick_default_title" msgid="752429113115293087">"Isključeno"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kratko"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekunde"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Srednje"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundi"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Dugo"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunda"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Prilagođeno"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kraće"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Duže"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Trajanje automatskog klika"</string>
    <string name="accessibility_vibration_settings_title" msgid="5198184603753129450">"Snaga vibracije i dodira"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibracija obavještenja"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibracija pri zvonu"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Vibracija na dodir"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Korištenje aplikacije <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Otvaranje aplikacije <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Koristi ispravku boja"</string>
    <string name="accessibility_caption_primary_switch_title" msgid="8901149325574757370">"Prikaži titlove"</string>
    <string name="accessibility_caption_primary_switch_summary" msgid="2754071646412717674">"Samo za podržane aplikacije"</string>
    <string name="captioning_caption_appearance_title" msgid="4501313548541670063">"Veličina i stil titlova"</string>
    <string name="captioning_caption_appearance_summary" msgid="7340741178479381312">"Veličina teksta: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Više opcija"</string>
    <string name="accessibility_caption_preference_summary" msgid="1191356970836416954">"Neke aplikacije ne podržavaju ove postavke titlova"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Prevlačenje pomoću 2 prsta s dna ekrana prema gore"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Držite tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trostruki dodir ekrana"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Nastavi"</string>
    <string name="accessibility_hearingaid_title" msgid="427173678199203191">"Slušni aparat"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"Nije povezan nijedan slušni aparat"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodaj slušne aparate"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="8913409742121315657">"Da uparite slušne aparate, pronađite i dodirnite svoj uređaj na sljedećem ekranu. Provjerite jesu li slušni aparati u načinu rada uparivanja."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> aktivan"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="776000580683647556">
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušni aparat sačuvan</item>
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušna aparata sačuvana</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušnih aparata sačuvano</item>
    </plurals>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Automatsko podešavanje"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Prečica je uključena"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Isključeno"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Uključeno"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Isključeno"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Ne radi. Dodirnite za informacije."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Ova usluga ne radi ispravno."</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Prikaži u Brzim postavkama"</string>
    <string name="daltonizer_type" msgid="1715154680803795947">"Način rada za ispravku"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="3811397143576433035">"Deuteranomalija"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6787594316700223938">"Protanomalija"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="1869867447813349033">"Tritanomalija"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Nijanse sive"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="791173297742998942">"Crveno-zeleno"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="482834207025141433">"Crveno-zeleno"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2837137091067433059">"Plavo-žuto"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5354221071353645263">
      <item quantity="one">Kratko (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunda)</item>
      <item quantity="few">Kratko (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde)</item>
      <item quantity="other">Kratko (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundi)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_medium_delay" formatted="false" msgid="1550891909800510628">
      <item quantity="one">Srednje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunda)</item>
      <item quantity="few">Srednje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde)</item>
      <item quantity="other">Srednje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundi)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="2230755548820485984">
      <item quantity="one">Dugo (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunda)</item>
      <item quantity="few">Dugo (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde)</item>
      <item quantity="other">Dugo (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundi)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_delay_unit_second" formatted="false" msgid="4537791441118261556">
      <item quantity="one"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekunda</item>
      <item quantity="few"><xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde</item>
      <item quantity="other"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekundi</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="27904038683405084">"Jačina zvuka zvona <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, obavještenje <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>, dodir <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="7776105450117095736">"Zvono i obavještenje su postavljeni na isključeno"</string>
    <string name="accessibility_vibration_summary_low" msgid="6482721005400340317">"Zvono i obavještenje su postavljeni na slabo"</string>
    <string name="accessibility_vibration_summary_medium" msgid="2348889320548746469">"Zvono i obavještenje su postavljeni na srednje"</string>
    <string name="accessibility_vibration_summary_high" msgid="1764693979030913712">"Zvono i obavještenje su postavljeni na jako"</string>
    <string name="accessibility_vibration_intensity_off" msgid="972159695404061944">"Isključeno"</string>
    <string name="accessibility_vibration_intensity_low" msgid="6311161118835287335">"Slabo"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="1734058611879392797">"Srednje"</string>
    <string name="accessibility_vibration_intensity_high" msgid="5982896399775212514">"Jako"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Postavke"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Uključeno"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Isključeno"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Pregled"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardne opcije"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Jezik"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Veličina teksta"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Stil titlova"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Prilagođene opcije"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Boja pozadine"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Prozirnost pozadine"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Boja prozora za titlove"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Prozirnost prozora naslova"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Boja teksta"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Prozirnost teksta"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Boja rubova"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Vrsta rubova"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Porodica fontova"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Titlovi će izgledati ovako"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Zadano"</string>
    <string name="color_title" msgid="2511586788643787427">"Boja"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Zadano"</string>
    <string name="color_none" msgid="3703632796520710651">"Nema boje"</string>
    <string name="color_white" msgid="1896703263492828323">"Bijela"</string>
    <string name="color_gray" msgid="8554077329905747877">"Siva"</string>
    <string name="color_black" msgid="9006830401670410387">"Crna"</string>
    <string name="color_red" msgid="5210756997426500693">"Crvena"</string>
    <string name="color_green" msgid="4400462091250882271">"Zelena"</string>
    <string name="color_blue" msgid="4997784644979140261">"Plava"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cijan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Žuta"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Dozvoliti da usluga <xliff:g id="SERVICE">%1$s</xliff:g> ima punu kontrolu nad vašim uređajem?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"Usluga <xliff:g id="SERVICE">%1$s</xliff:g> treba da:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Aplikacija nije dala odobrenje za zahtjev pa postavke ne mogu potvrditi vaš odgovor."</string>
    <string name="enable_service_encryption_warning" msgid="931082737770453755">"Ukoliko uključite uslugu <xliff:g id="SERVICE">%1$s</xliff:g>, uređaj neće koristiti zaključavanje ekrana za poboljšanje šifriranja podataka."</string>
    <string name="secure_lock_encryption_warning" msgid="669152607190123579">"Pošto ste uključili uslugu pristupačnosti, vaš uređaj neće koristiti zaključavanje ekrana za poboljšanje šifriranja podataka."</string>
    <string name="enable_service_pattern_reason" msgid="6832846117817938536">"Uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifriranje podataka, stoga je potrebno da potvrdite svoj obrazac."</string>
    <string name="enable_service_pin_reason" msgid="6040417014360237703">"Uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifriranje podataka, stoga je potrebno da potvrdite svoj PIN."</string>
    <string name="enable_service_password_reason" msgid="6962544350351734238">"Uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifriranje podataka, stoga je potrebno da potvrdite lozinku."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"Usluga <xliff:g id="SERVICE">%1$s</xliff:g> zahtijeva potpunu kontrolu ovog uređaja. Usluga može čitati sadržaj ekrana i djelovati u ime korisnika s potrebama za pristupačnost. Ovaj nivo kontrole nije prikladan za većinu aplikacija."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Puna kontrola je prikladna za aplikacije koje vam pomažu kod potreba za pristupačnosti, ali nije za većinu aplikacija."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Prikaz i kontrola ekrana"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Može čitati sav sadržaj na ekranu i prikazivati sadržaj u drugim aplikacijama."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Prikaz i izvršavanje radnji"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Može pratiti vaše interakcije s aplikacijom ili hardverskim senzorom te ostvariti interakciju s aplikacijama umjesto vas."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Dozvoli"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Odbij"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Zaustavi"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Otkaži"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Zaustaviti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Dodirom na <xliff:g id="STOP">%1$s</xliff:g> zaustavit će se usluga <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nema instaliranih usluga"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nije odabrana usluga"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nije naveden opis."</string>
    <string name="settings_button" msgid="2195468788019730377">"Postavke"</string>
    <string name="print_settings" msgid="8519810615863882491">"Štampanje"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Isključeno"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="1034273609054146099">
      <item quantity="one">Uključena je <xliff:g id="COUNT">%1$d</xliff:g> usluga štampanja</item>
      <item quantity="few">Uključene su <xliff:g id="COUNT">%1$d</xliff:g> usluge štampanja</item>
      <item quantity="other">Uključeno je <xliff:g id="COUNT">%1$d</xliff:g> usluga štampanja</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="3933688846338306536">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> zadatak za štampanje</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g>zadatka za štampanje</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g>zadataka za štampanje</item>
    </plurals>
    <string name="print_settings_title" msgid="7680498284751129935">"Usluge štampanja"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nema instaliranih usluga"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nije pronađen nijedan štampač"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Postavke"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Dodaj pisače"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Uključeno"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Isključeno"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Dodajte uslugu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Dodaj štampač"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Pretražite"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Pretraživanje štampača"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Usluga je onemogućena"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Zadaci štampanja"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Zadatak ispisivanja"</string>
    <string name="print_restart" msgid="4424096106141083945">"Ponovo pokreni"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Otkaži"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<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="2887013172492183045">"Konfiguriranje za <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Štampa se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Otkazuje se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Greška pisača <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Štampač je blokirao <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Okvir za pretraživanje je prikazan"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Okvir za pretraživanje je skriven"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Više informacija o ovom štampaču"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterija"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Šta je sve koristilo bateriju"</string>
    <string name="power_usage_not_available" msgid="3425302437465106036">"Nema podataka o potrošnji baterije."</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Preostalo <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do pune baterije"</string>
    <string name="background_activity_title" msgid="8214332017349791380">"Ograničenje rada u pozadini"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Dopustite aplikaciji da radi u pozadini"</string>
    <string name="background_activity_summary_disabled" msgid="32459916080651444">"Aplikaciji nije dopušteno da radi u pozadini"</string>
    <string name="background_activity_summary_allowlisted" msgid="6240154358657454651">"Nije moguće ograničiti upotrebu u pozadini"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Ograničiti aktivnost u pozadini?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ako aplikaciji ograničite aktivnost u pozadini, može raditi nepravilno"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Aplikaciju ne možete ograničiti jer nije postavljena optimizacija baterije.\n\nDa je ograničite prvo uključite optimizaciju."</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Korištenje ekrana od potpune napunjenosti"</string>
    <string name="power_usage_list_summary" msgid="3237540201918492925">"Potrošnja baterije od potpune napunjenosti"</string>
    <string name="screen_usage_summary" msgid="1393184943010909471">"Vrijeme koliko je ekran uključen od potpune napunjenosti"</string>
    <string name="device_usage_list_summary" msgid="242243537371697285">"Korištenje uređaja od potpune napunjenosti"</string>
    <string name="battery_since_unplugged" msgid="6991509383429936921">"Potrošnja baterije od isključivanja s napajanja"</string>
    <string name="battery_since_reset" msgid="2930376112877476562">"Potrošnja baterije od posljednjeg pokretanja"</string>
    <string name="battery_stats_on_battery" msgid="1553011980384645514">"<xliff:g id="TIME">%1$s</xliff:g> rada na bateriji"</string>
    <string name="battery_stats_duration" msgid="6918768703070999743">"<xliff:g id="TIME">%1$s</xliff:g> od isključivanja s napajanja"</string>
    <string name="battery_stats_charging_label" msgid="6204814386861342145">"Punjenje"</string>
    <string name="battery_stats_screen_on_label" msgid="8989312180491200138">"Ekran uključen"</string>
    <string name="battery_stats_gps_on_label" msgid="5626424078405382686">"GPS uključen"</string>
    <string name="battery_stats_camera_on_label" msgid="555635201416769359">"Kamera je uključena"</string>
    <string name="battery_stats_flashlight_on_label" msgid="1621027969559427783">"Svjetiljka je uključena"</string>
    <string name="battery_stats_wifi_running_label" msgid="6461551370010379049">"WiFi"</string>
    <string name="battery_stats_wake_lock_label" msgid="8115041205778441548">"Aktivan"</string>
    <string name="battery_stats_phone_signal_label" msgid="679649411998679555">"Signal mobilne mreže"</string>
    <!-- no translation found for battery_stats_last_duration (3088100394725340600) -->
    <skip />
    <string name="awake" msgid="5405871714019268978">"Vrijeme aktivnosti uređaja"</string>
    <string name="wifi_on_time" msgid="3880778525760926066">"Wi‑Fi na vrijeme"</string>
    <string name="bluetooth_on_time" msgid="8424625554628450028">"Wi‑Fi na vrijeme"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Potrošnja baterije"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalji historije"</string>
    <!-- no translation found for advanced_battery_preference_title (6518802648205311326) -->
    <skip />
    <string name="battery_details_title" msgid="4531369291819754178">"Potrošnja baterije"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detalji o upotrebi"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Podesite potrošnju energije"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Uključeni paketi"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikacije rade uobičajeno"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="6077959765904507849">"Telefon ima uobičajenu potrošnju baterije u pozadini"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="5063158368808711973">"Tablet ima uobičajenu potrošnju baterije u pozadini"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="4242899844618910548">"Uređaj ima uobičajenu potrošnju baterije u pozadini"</string>
    <string name="battery_tip_low_battery_title" msgid="7789690720316830767">"Nizak kapacitet baterije"</string>
    <string name="battery_tip_low_battery_summary" msgid="357649681960300945">"Baterija ne može osigurati dobar vijek trajanja"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2903272443772298636">"Poboljšajte vijek trajanja baterije telefona"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6813017377960004819">"Poboljšajte vijek trajanja baterije tableta"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4805599360437606335">"Poboljšajte vijek trajanja baterije uređaja"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Uključite Upravitelja baterije"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Uključite Uštedu baterije"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Baterija bi vam se mogla isprazniti brže nego obično"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4413270905575486715">"Uključena je Ušteda baterije"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Neke funkcije mogu biti ograničene"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="2375953293196088319">"Koristili ste telefon više nego obično"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="8515903411746145740">"Koristili ste tablet više nego obično"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="6577086402173910457">"Koristili ste uređaj više nego obično"</string>
    <string name="battery_tip_high_usage_summary" msgid="5356399389711499862">"Baterija bi vam se mogla isprazniti brže nego obično"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="7152799456221596915">"Optimiziranje radi očuvanja baterije"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="6837061824463128857">"Baterija je privremeno ograničena. Dodirnite da saznate više."</string>
    <string name="battery_tip_dialog_message" product="default" msgid="4681734836472195966">"Vaš telefon je korišten više nego obično. Baterija se može istrošiti brže nego što je predviđeno.\n\nAplikacije koje najviše troše bateriju:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="3934298305232120382">"Vaš tablet je korišten više nego obično. Baterija se može istrošiti brže nego što je predviđeno.\n\nAplikacije koje najviše troše bateriju:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="2620789680336796054">"Vaš uređaj je korišten više nego obično. Baterija se može istrošiti brže nego što je predviđeno.\n\nAplikacije koje najviše troše bateriju:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Uključuje aktivnost u pozadini s velikom potrošnjom baterije"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="3108195491484891588">
      <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="5862649927574803958">
      <item quantity="one">%2$d aplikacija je nedavno ograničena</item>
      <item quantity="few">%2$d aplikacije su nedavno ograničene</item>
      <item quantity="other">%2$d aplikacija je nedavno ograničeno</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="3328499737453686910">
      <item quantity="one">%2$d aplikacija ima visoku potrošnju baterije u pozadini</item>
      <item quantity="few">%2$d aplikacije imaju visoku potrošnju baterije u pozadini</item>
      <item quantity="other">%2$d aplikacija ima visoku potrošnju baterije u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="3036853535034350991">
      <item quantity="one">Ove aplikacije ne mogu raditi u pozadini</item>
      <item quantity="few">Ove aplikacije ne mogu raditi u pozadini</item>
      <item quantity="other">Ove aplikacije ne mogu raditi u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="7897944678619251740">
      <item quantity="one">Ograničiti %1$d aplikaciju?</item>
      <item quantity="few">Ograničiti %1$d aplikacije?</item>
      <item quantity="other">Ograničiti %1$d aplikacija?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Da uštedite bateriju, spriječite aplikaciju <xliff:g id="APP">%1$s</xliff:g> da koristi bateriju u pozadini. Moguće je da ta aplikacija neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Da uštedite bateriju, spriječite ove aplikacije da koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Da uštedite bateriju, spriječite ove aplikacije da koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti.\n\nAplikacije:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Ograniči"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Ukloniti ograničenje?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Ova aplikacija će moći koristiti bateriju u pozadini. Vaša baterija bi se mogla isprazniti prije nego što očekujete."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Ukloni"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Otkaži"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="6097167058237891756">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako aplikacije budu prebrzo trošile bateriju, telefon će predložiti radnje koje možete preduzeti.\n\nUvijek možete uključiti Uštedu baterije ako je baterija skoro prazna."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="573297655597451123">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako aplikacije budu prebrzo trošile bateriju, tablet će predložiti radnje koje možete preduzeti.\n\nUvijek možete uključiti Uštedu baterije ako je baterija skoro prazna."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="8222461068860745749">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako aplikacije budu prebrzo trošile bateriju, uređaj će predložiti radnje koje možete preduzeti.\n\nUvijek možete uključiti Uštedu baterije ako je baterija skoro prazna."</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Upravitelj baterije"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Automatsko upravljanje aplikacijama"</string>
    <string name="smart_battery_summary" product="default" msgid="1492277404000064998">"Ograničite upotrebu baterije za aplikacije koje ne koristite često"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kada Upravitelj baterije otkrije da aplikacije troše bateriju, imat ćete opciju da na te aplikacije postavite ograničenje. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Ograničene aplikacije"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="6059772951505411003">
      <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="3097721884155913252">"Ograničeno <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3683577206409650564">"Ove aplikacije koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Upotreba Upravitelja baterije"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Otkrij kada aplikacije troše bateriju"</string>
    <string name="battery_manager_on" product="default" msgid="3197525907390349054">"Uključeno / Otkrivanje kada aplikacije troše bateriju"</string>
    <string name="battery_manager_off" msgid="673547668722420924">"Isključeno"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="6714534362166394848">
      <item quantity="one">Ograničena je %1$d aplikacija</item>
      <item quantity="few">Ograničene su %1$d aplikacije</item>
      <item quantity="other">Ograničeno je %1$d aplikacija</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="5202575301365811053">"Došlo je do problema prilikom očitavanja mjerača stanja baterije"</string>
    <string name="battery_missing_help_message" msgid="4583322687535428926">"Došlo je do problema prilikom očitavanja mjerača stanja baterije. Dodirnite da "<annotation id="url">"saznate više"</annotation>"."</string>
    <string name="dialog_stop_title" msgid="5972757101865665655">"Želite zaustaviti aplikaciju?"</string>
    <string name="dialog_stop_message" product="default" msgid="2063536418875183799">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno drži vaš telefon aktivnim.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message" product="tablet" msgid="426862716783569739">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno drži vaš tablet aktivnim.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message" product="device" msgid="4252335402634772603">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno drži vaš uređaj aktivnim.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="604462000476810125">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže telefon iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="7737426241260791605">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže tablet iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="1820679795932901383">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže uređaj iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_ok" msgid="1171516542217183180">"Zaustavi aplikaciju"</string>
    <string name="dialog_background_check_title" msgid="8571605969100408762">"Želite li isključiti korištenje u pozadini i zaustaviti aplikaciju?"</string>
    <string name="dialog_background_check_message" product="default" msgid="6203374578970183277">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže vaš telefon iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njen rad u pozadini."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="1282389215667916176">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže vaš tablet iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njen rad u pozadini."</string>
    <string name="dialog_background_check_message" product="device" msgid="8005524265739819577">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže vaš uređaj iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njen rad u pozadini."</string>
    <string name="dialog_background_check_ok" msgid="5792934035264144797">"Isključi"</string>
    <string name="dialog_location_title" msgid="1323400468370901875">"Želite li isključiti uslugu lokacije?"</string>
    <string name="dialog_location_message" product="default" msgid="5597959072209122057">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži vašu lokaciju kada je ne koristite.\n\nDa pokušate riješiti ovaj problem, možete isključiti lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_message" product="tablet" msgid="7165269165194599595">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži vašu lokaciju kada je ne koristite.\n\nDa pokušate riješiti ovaj problem, možete isključiti lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_message" product="device" msgid="4606829479989940464">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži vašu lokaciju kada je ne koristite.\n\nDa pokušate riješiti ovaj problem, možete isključiti lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_ok" msgid="6338680851382069716">"Isključi"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekran"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Svjetiljka"</string>
    <string name="power_camera" msgid="4778315081581293923">"Fotoaparat"</string>
    <string name="power_wifi" msgid="4614007837288250325">"WiFi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="5507921058696341513">"Mobilna mreža u stanju mirovanja"</string>
    <string name="power_phone" msgid="2768396619208561670">"Glasovni pozivi"</string>
    <string name="power_idle" product="tablet" msgid="4689321599298911021">"Tablet u stanju mirovanja"</string>
    <string name="power_idle" product="default" msgid="9132502722499465252">"Telefon u stanju mirovanja"</string>
    <string name="power_unaccounted" msgid="2160811497426475703">"Razno"</string>
    <string name="power_overcounted" msgid="3681101460287472876">"Prekoračenje izračuna"</string>
    <string name="usage_type_cpu" msgid="8544148642836549011">"Ukupno CPU"</string>
    <string name="usage_type_cpu_foreground" msgid="6120871498122604239">"CPU u prvom planu"</string>
    <string name="usage_type_wake_lock" msgid="3442487584173668904">"Drži aktivnim"</string>
    <string name="usage_type_gps" msgid="4118035982288964651">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="5573404832197356206">"Funkcioniranje WiFi-ja"</string>
    <string name="usage_type_phone" product="tablet" msgid="4527092861928972130">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="4149330237181984782">"Telefon"</string>
    <string name="usage_type_data_send" msgid="4375755152437282184">"Poslani mobilni paketi"</string>
    <string name="usage_type_data_recv" msgid="7821924049621005218">"Primljeni mobilni paketi"</string>
    <string name="usage_type_radio_active" msgid="1876069445855950097">"Mobilni radio aktivan"</string>
    <string name="usage_type_data_wifi_send" msgid="6154038607322769558">"WiFi paketi koji se šalju"</string>
    <string name="usage_type_data_wifi_recv" msgid="4821128213012023100">"Primljeni WiFi paketi"</string>
    <string name="usage_type_audio" msgid="1100651355357912864">"Zvuk"</string>
    <string name="usage_type_video" msgid="1068481638906679035">"Video"</string>
    <string name="usage_type_camera" msgid="3999579307204257822">"Kamera"</string>
    <string name="usage_type_flashlight" msgid="5629235220169383309">"Svjetiljka"</string>
    <string name="usage_type_on_time" msgid="104642441471272535">"Vrijeme rada"</string>
    <string name="usage_type_no_coverage" msgid="1385712176630900103">"Vrijeme bez signala"</string>
    <string name="usage_type_total_battery_capacity" msgid="3878234027503885998">"Ukupni kapacitet baterije"</string>
    <string name="usage_type_computed_power" msgid="5191902025833668752">"Izračunata potrošnja energije"</string>
    <string name="usage_type_actual_power" msgid="1221358930299037926">"Uočena potrošnja energije"</string>
    <string name="battery_action_stop" msgid="6998228610098034316">"Prisilno zaustavi"</string>
    <string name="battery_action_app_details" msgid="7201369216798227707">"Informacije o aplikaciji"</string>
    <string name="battery_action_app_settings" msgid="2437124469335488464">"Postavke aplikacije"</string>
    <string name="battery_action_display" msgid="6515712081248863749">"Postavke ekrana"</string>
    <string name="battery_action_wifi" msgid="1829212604573932607">"Postavke za WiFi"</string>
    <string name="battery_action_bluetooth" msgid="4723692623358386789">"Bluetooth postavke"</string>
    <string name="battery_desc_voice" msgid="6900799826084022585">"Korištenje baterije za govorne pozive"</string>
    <string name="battery_desc_standby" product="tablet" msgid="5818742458684767043">"Korištenje baterije kada je tablet neaktivan"</string>
    <string name="battery_desc_standby" product="default" msgid="2543075041964578103">"Potrošnja baterije kada je telefon u stanju pripravnosti"</string>
    <string name="battery_desc_radio" msgid="454677140485133914">"Potrošnja baterije za mobilni radio"</string>
    <string name="battery_sugg_radio" msgid="5476234634503535270">"Prebacite se na način rada u avionu kako biste štedili napajanje na područjima u kojima nema pokrivenosti mobilnom mrežom"</string>
    <string name="battery_desc_flashlight" msgid="6694895513133361404">"Potrošnja baterije upotrebom svjetiljke"</string>
    <string name="battery_desc_camera" msgid="6152712271731518018">"Potrošnja baterije upotrebom kamere"</string>
    <string name="battery_desc_display" msgid="7175017688954602685">"Potrošnja baterije na prikaz i pozadinsko osvjetljenje"</string>
    <string name="battery_sugg_display" msgid="3102137296547788111">"Smanjite osvijetljenost ekrana i/ili trajanje perioda do isteka vremena ekrana"</string>
    <string name="battery_desc_wifi" msgid="5276669172548928768">"Korištenje baterije za WiFi"</string>
    <string name="battery_sugg_wifi" msgid="359757575108350109">"Isključite WiFi kada se ne koristi ili kada nije dostupan"</string>
    <string name="battery_desc_bluetooth" msgid="2237947137783306282">"Potrošnja baterije za Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="8943564578546832037">"Isključite Bluetooth kada se ne koristi"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="6495519793211758353">"Pokušajte se povezati na drugi Bluetooth uređaj"</string>
    <string name="battery_desc_apps" msgid="4187483940383266017">"Potrošnja baterije za aplikaciju"</string>
    <string name="battery_sugg_apps_info" msgid="4796917242296658454">"Zaustavi ili deinstaliraj aplikaciju"</string>
    <string name="battery_sugg_apps_gps" msgid="7221335088647925110">"Odaberite režim uštede baterije"</string>
    <string name="battery_sugg_apps_settings" msgid="6527223370162382166">"Aplikacija može sadržavati postavke da smanji potrošnju baterije"</string>
    <string name="battery_desc_users" msgid="1959428568888686847">"Baterija koju troši korisnik"</string>
    <string name="battery_desc_unaccounted" msgid="1649497860893660763">"Nedefinisana potrošnja energije"</string>
    <string name="battery_msg_unaccounted" msgid="5647345548624995064">"Potrošnja baterije je približna vrijednost potrošnje energije te ne uključuje svaki izvor potrošnje baterije. Nedefinisana potrošnja je razlika između izračunate približne potrošnje energije i stvarne potrošnje koja se uočava na bateriji."</string>
    <string name="battery_desc_overcounted" msgid="5982079150027267539">"Prekoračenje potrošnje energije"</string>
    <string name="mah" msgid="3604527474433227780">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="6401552215008504483">"Korišteno <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="4416277218863232476">"Aktivna već <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Korištenje ekrana <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"Aplikacija <xliff:g id="APP">%2$s</xliff:g> koristi <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> ukupne baterije"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Pregled od posljednje potpune napunjenosti"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Posljednja potpuna napunjenost"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Potpuna napunjenost traje"</string>
    <string name="battery_footer_summary" msgid="9125397752380281832">"Podaci o potrošnji baterije su približni i mogu se promijeniti u zavisnosti od korištenja"</string>
    <string name="battery_detail_foreground" msgid="3312280147931093967">"Dok se aktivno koristi"</string>
    <string name="battery_detail_background" msgid="3333915023706228000">"Dok je u pozadini"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Potrošnja baterije"</string>
    <string name="battery_detail_info_title" msgid="5896661833554333683">"Od potpune napunjenosti"</string>
    <string name="battery_detail_manage_title" msgid="7910805419446927887">"Upravljanje korištenjem baterije"</string>
    <string name="advanced_battery_graph_subtext" msgid="6816737986172678550">"Procjena preostalog trajanja baterije zasnovana je na korištenju uređaja"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Procjena preostalog vremena"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Do potpune napunjenosti"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Procjena se može mijenjati u zavisnosti od korištenja"</string>
    <string name="menu_stats_unplugged" msgid="7125297366200634285">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od isključivanja s napajanja"</string>
    <string name="menu_stats_last_unplugged" msgid="230678127178268655">"Tokom posljednjeg isključivanja s napajanja <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="2713445396954503670">"Ukupno korištenje"</string>
    <string name="menu_stats_refresh" msgid="6727628139586938835">"Osvježi"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Server za medijske sadržaje"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimizacija aplikacija"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Ušteda baterije"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Automatski uključi"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Nema rasporeda"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Na osnovu vaše rutine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Na osnovu postotka"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Ušteda baterije će se uključiti ako je vjerovatno da će se baterija istrošiti prije sljedećeg uobičajenog punjenja"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Uključit će se na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Postavite raspored"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Produžite vijek trajanja baterije"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Isključi nakon punjenja"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="4969508893424116609">"Ušteda baterije se isključuje kada se telefon napuni više od <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6613068787945311001">"Ušteda baterije se isključuje kada se tablet napuni više od <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8707774542183385479">"Ušteda baterije se isključuje kada se uređaj napuni više od <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Uključi"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Koristi Uštedu baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Automatsko uključivanje"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikad"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"na <xliff:g id="PERCENT">%1$s</xliff:g> baterije"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Postotak napunjenosti baterije"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Prikaz postotka napunjenosti baterije na statusnoj traci"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistika procesa"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Geeky statistike o pokrenutim procesima"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Iskorištena memorija"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> od <xliff:g id="TOTALRAM">%2$s</xliff:g> korišteno tokom zadnjih <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> RAM-a korišteno tokom <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Pozadina"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Prvi plan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Keširano"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Izvorni"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Keš-memorije"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Upotreba RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Korištenje RAM-a (u pozadini)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Vrijeme izvršavanja"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesi"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Usluge"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Trajanje"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detalji o memoriji"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 sata"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 sati"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 sati"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 dan"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Prikaži sistemske procese"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Sakrij sistemske procese"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Prikaži postotke"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Koristi Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Tip statističkih podataka"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Pozadina"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Prvi plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Keširano"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Glasovni unos i izlaz"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Postavke glasovnog unosa i izlaza"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Glasovno pretraživanje"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android tastatura"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Podešavanja govornog unosa"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Govorni unos"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Usluge govornog unosa"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Cela aktuelna reč i interakcija"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Jednostavno pretvaranje govora u tekst"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Ova usluga za glasovni unos će biti u mogućnosti da obavlja uvijek uključeno praćenje glasa i da u vaše ime kontrolira aplikacije omogućene glasom. Ona dolazi iz <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g> aplikacija. Omogućiti korištenje ove usluge?"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Željeni alat"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Postavke programa"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Brzina govora i visina glasa"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Program"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Jezik govora"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalirajte Glasove"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Nastavite na aplikaciju <xliff:g id="TTS_APP_NAME">%s</xliff:g> da instalirate glasove"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Otvori aplikaciju"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Otkaži"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Vrati na zadano"</string>
    <string name="tts_play" msgid="2945513377250757221">"Pokreni"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Prilagodljiva povezivost"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Produžava vijek trajanja baterije i poboljšava performanse uređaja automatskim upravljanjem vaših mrežnih veza"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Pohrana akreditiva"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instaliranje certifikata"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="6644116499934553975">"Instaliranje certifikata iz pohrane"</string>
    <string name="credentials_install_summary" product="default" msgid="8161351950524166012">"Instaliraj certifikate sa SD kartice"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Brisanje akreditiva"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Uklanjanje svih certifikata"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Pouzdani akreditivi"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Prikaz pouzdanih CA certifikata"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Korisnički akreditivi"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Prikaz i izmjena pohranjenih akreditiva"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Napredno"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Akreditivi nisu dostupni za ovog korisnika"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instalirani za VPN i aplikacije"</string>
    <string name="credential_for_wifi" msgid="1963335263280604998">"Instalirani za WiFi mrežu"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Ukloniti sav sadržaj?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Pohrana akreditiva je izbrisana."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Nije uspjelo bris. memorije vjerodaj."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apl. s pristupom pod. o korišt."</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA certifikat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Korisnički cert. za VPN i apl."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certifikat za WiFi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Vaši podaci neće biti privatni"</string>
    <string name="ca_certificate_warning_description" msgid="3386740654961466569">"Web lokacije, aplikacije i VPN-ovi koriste CA certifikate za šifriranje. Instalirajte CA certifikate samo ako dolaze od organizacija kojima vjerujete. \n\n Ako instalirate CA certifikat, vlasnik certifikata može pristupiti vašim podacima, kao što su lozinke ili detalji o kreditnoj kartici, s web lokacija koje posjećujete ili aplikacija koje koristite, čak i ako su ti podaci šifrirani."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Nemoj instalirati"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Ipak instaliraj"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Potvrda nije instalirana"</string>
    <string name="request_manage_credentials_title" msgid="4524504926699928916">"Dozvoliti aplikaciji <xliff:g id="APP_NAME">%s</xliff:g> da instalira certifikate na ovaj uređaj?"</string>
    <string name="request_manage_credentials_description" msgid="4969609158022551952">"Ovi certifikati će vas identificirati aplikacijama i URL-ovima ispod"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nemoj dozvoliti"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Dozvoli"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Prikaži više"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Apl. za upravljanje certifik."</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Nema"</string>
    <string name="certificate_management_app_description" msgid="7257420502179110164">"Certifikati koje je instalirala ova aplikacija vas identificiraju aplikacijama i URL-ovima navedenim u nastavku"</string>
    <string name="remove_credential_management_app" msgid="6879631067380232928">"Ukloni"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signal za hitne pozive"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Postavi ponašanje prilikom upućivanja poziva za hitne situacije"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Izrada sigurnosnih kopija"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Uključeno"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Isključeno"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Sigurnosna kopija i vraćanje"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Lični podaci"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Izrada sigurnosnih kopija podataka"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Pravite sigurnosne kopije podataka aplikacija, lozinki za WiFi te drugih postavki na Google serverima"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Račun za sigurnosne kopije"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Upravljajte računom za sigurnosne kopije"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Uvrstite podatke aplikacije"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatsko vraćanje"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Prilikom ponovnog instaliranja aplikacije, vraća sigurnosne kopije postavki i podataka"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Usluga za izradu sigurnosne kopije nije aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Nijedan račun trenutno ne pravi sigurnosne kopije podataka"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Želite li prestati sa izradom sigurnosnih kopija lozinki za WiFi, oznaka, drugih postavki te podataka aplikacija i izbrisati sve kopije sa Google servera?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Prestani da praviš sigurnosne kopije podataka (npr. lozinke za WiFi i istorija poziva) i podataka aplikacije (npr. postavke i fajlovi koje pohranjuju aplikacije), i izbriši sve kopije na udaljenim serverima?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Daljinski pokrenite automatsku izradu sigurnosnih kopija podataka na uređaju (npr. WiFi lozinki i historije poziva) i podataka iz aplikacija (npr. postavki i fajlova koje pohranjuju aplikacije).\n\nKada uključite automatsku izradu sigurnosnih kopija, podaci iz uređaja i aplikacija se periodično pohranjuju daljinski. Podaci iz aplikacije mogu biti bilo koji podaci koje je aplikacija sačuvala (na osnovu programerskih postavki), uključujući i potencijalno osjetljive podatke, kao što su kontakti, poruke i fotografije."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Postavke administratora uređaja"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplikacija administratora uređaja"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktiviraj ovu aplikaciju administratora uređaja"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Deinstaliraj aplikaciju"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktiviraj i deinstaliraj"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplikacije administratora uređaja"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nema dostupnih aplikacija administratora uređaja"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nema dostupnih pouzdanih agenata"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivirati aplikaciju administratora uređaja?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiviraj aplikaciju administratora uređaja"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrator uređaja"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Ako aktivirate ovu aplikaciju administratora, omogućit ćete aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvršava sljedeće operacije:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> će pratiti ovaj uređaj i upravljati njime."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Ova aplikacija administratora je aktivna i omogućava aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvršava sljedeće operacije:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Aktivirati Upravitelj profila?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Dozvoliti nadzor?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ako nastavite, vašim korisnikom će upravljati vaš administrator koji će, osim vaših ličnih podataka, moći pohranjivati i povezane podatke.\n\nVaš administrator može pratiti i upravljati postavkama, pristupom, aplikacijama i podacima koji su povezani s ovim korisnikom, uključujući aktivnost na mreži i informacije o lokaciji vašeg uređaja."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Administrator je onemogućio ostale opcije"</string>
    <string name="admin_more_details" msgid="6698424974827333973">"Više detalja"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Zapisnik obavještenja"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historija obavještenja"</string>
    <string name="notification_history_today" msgid="5828496957208237230">"Posljednja 24 sata"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Odgođeno"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nedavno odbačeno"</string>
    <plurals name="notification_history_count" formatted="false" msgid="1859304685071321991">
      <item quantity="one"><xliff:g id="NUMBER_1">%d</xliff:g> obavještenje</item>
      <item quantity="few"><xliff:g id="NUMBER_1">%d</xliff:g> obavještenja</item>
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> obavještenja</item>
    </plurals>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Melodija zvona telefona i vibracija"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detalji o mreži"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinhronizacija omogućena"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinhronizacija onemogućena"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sinhronizuje se"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Greška pri sinhroniziranju."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinhronizacija nije uspjela"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinhronizacija aktivna"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinhroniziraj"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Trenutno ima problema sa sinhroniziranjem. Ubrzo će opet raditi."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Dodaj račun"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Radni profil još uvijek nije dostupan"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Radni profil"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Upravlja vaša organizacija"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Aplikacije i obavještenja su isključeni"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Ukloni radni profil"</string>
    <string name="background_data" msgid="321903213000101158">"Podaci u pozadini"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikacije mogu sinhronizirati, slati i primati podatke u bilo koje vrijeme"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Onemogućiti podatke u pozadini?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Onemogućavanjem prijenosa podataka u pozadini produžava se trajanje baterije i smanjuje korištenje podataka. Neke aplikacije mogu i dalje koristiti vezu za prijenos podataka u pozadini."</string>
    <string name="sync_automatically" msgid="4874122892765430304">"Aut. sinhronizir. podat. aplikacija"</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinhronizacija UKLJUČENA"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinhronizacija ISKLJUČENA"</string>
    <string name="sync_error" msgid="846923369794727644">"Greška u sinhroniziranju"</string>
    <string name="last_synced" msgid="1527008461298110443">"Posljednje sinhroniziranje: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sinhroniziraj sada…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Napravi rezervnu kopiju postavki"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Napravi rezervnu kopiju mojih postavki"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinhroniziraj sada"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Otkaži sinhroniziranje"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Dodirnite da sinhronizirate odmah<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalendar"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakti"</string>
    <string name="sync_plug" msgid="7956982719077985381"><font fgcolor="#ffffffff">"Dobro došli u Google sync!"</font>" \nGoogle pristup sinhroniziranju podataka kako bi se omogućio pristup vašim kontaktima, obavezama i drugim stavkama gdje god da se nalazite."</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Postavke sinhroniziranja aplikacija"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Podaci i sinhroniziranje"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Promijenite lozinku"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Postavke računa"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Ukloni račun"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Dodajte račun"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Ukloniti račun?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="8893801622174947887">"Uklanjanjem ovog računa će se izbrisati sve njegove poruke, kontakti i ostali podaci s tableta!"</string>
    <string name="really_remove_account_message" product="default" msgid="1217810840427479274">"Uklanjanjem ovog računa će se izbrisati sve njegove poruke, kontakti i ostali podaci s telefona!"</string>
    <string name="really_remove_account_message" product="device" msgid="5241756807386611084">"Uklanjanjem ovog računa izbrisat ćete sve njegove poruke, kontakte i druge podatke s uređaja!"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Vaš administrator ne dopušta ovu promjenu"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nije moguće ručno sinhronizovati"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Sinhornizacija za ovu stavku trenutno nije moguća. Da biste promijenili ovu postavku, privremeno uključite podatke u pozadini i automatsko sinhroniziranje."</string>
    <string name="enter_password" msgid="6327051330258595331">"Da biste pokrenuli Android, unesite lozinku"</string>
    <string name="enter_pin" msgid="1029287617551232681">"Da biste pokrenuli Android, unesite PIN"</string>
    <string name="enter_pattern" msgid="1747316785866742960">"Da biste pokrenuli Android, nacrtajte svoj obrazac"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="340747269176120242">"Pogrešan obrazac"</string>
    <string name="cryptkeeper_wrong_password" msgid="7295607881887114486">"Pogrešna lozinka"</string>
    <string name="cryptkeeper_wrong_pin" msgid="2347961593970714201">"Pogrešan PIN"</string>
    <string name="checking_decryption" msgid="6111642972615688237">"Provjera u toku..."</string>
    <string name="starting_android" msgid="6694154070215356186">"Pokretanje Androida…"</string>
    <string name="delete" msgid="8330605554706263775">"Izbriši"</string>
    <string name="misc_files" msgid="6598066985800749585">"Razni fajlovi"</string>
    <string name="misc_files_selected_count" msgid="5597802791672749532">"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="7622766714974500289">"<xliff:g id="NUMBER">%1$s</xliff:g> od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="7898929601615536401">"Označi sve"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Prijenos podataka"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Prijenos podataka na mobilnoj mreži i WiFi"</string>
    <string name="data_usage_accounting" msgid="6832015632699116754">"Obračun podataka operatera može se razlikovati od obračuna vašeg uređaja."</string>
    <string name="data_usage_app" msgid="6367974637783240699">"Korištenje aplikacija"</string>
    <string name="data_usage_app_info_label" msgid="3542220416056122841">"INFORMACIJE O APLIKACIJI"</string>
    <string name="data_usage_cellular_data" msgid="1917226172511825849">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="data_usage_data_limit" msgid="1120291692444009289">"Postavljanje ograničenja potrošnje"</string>
    <string name="data_usage_cycle" msgid="6875568429140150029">"Ciklus prijenosa podataka"</string>
    <string name="data_usage_app_items_header_text" msgid="7513812163443595033">"Korištenje aplikacije"</string>
    <string name="data_usage_menu_roaming" msgid="6864561338842056939">"Roming podataka"</string>
    <string name="data_usage_menu_restrict_background" msgid="1414574366645086133">"Ograniči podatke u pozadini"</string>
    <string name="data_usage_menu_allow_background" msgid="6242931073390680432">"Dopusti pozadinske podatke"</string>
    <string name="data_usage_menu_split_4g" msgid="3391899816926640583">"Odvojeno korišt. 4G veze"</string>
    <string name="data_usage_menu_show_wifi" msgid="6380926350184939975">"Prikaži WiFi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="4694889089278302691">"Sakrij WiFi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="4401026240876938859">"Prikaži korištenje Etherneta"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="7792365022467586772">"Sakrij korištenje podataka putem Etherneta"</string>
    <string name="data_usage_menu_metered" msgid="4279260736172851951">"Mrežna ograničenja"</string>
    <string name="data_usage_menu_auto_sync" msgid="2632694000068175025">"Automatsko sinhroniziranje podataka"</string>
    <string name="data_usage_menu_sim_cards" msgid="8966135605336735887">"SIM kartice"</string>
    <string name="data_usage_cellular_data_summary" msgid="8139993171126153316">"Pauzirano na ograničenju"</string>
    <string name="account_settings_menu_auto_sync" msgid="1660484779001900562">"Automatski sinhroniziraj podatke"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Automatska sinhronizacija ličnih podataka"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Automatska sinhronizacija podataka za posao"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Promijeni ciklus…"</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dan u mjesecu za poništavanje ciklusa prijenosa podataka:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Nijedna apl. nije koristila pod. u ovom periodu."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Prvi plan"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Pozadina"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"ograničeno"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Isključiti prijenos podataka na mobilnoj mreži?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Ograniči mobilne podatke"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Postavi ograničenje za 4G podatke"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Ograničenje 2G-3G podataka"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Ograniči WiFi podatke"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"WiFi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilni"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobilne"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Ništa"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilni podaci"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G-3G podaci"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G podaci"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Prvi plan:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Pozadina:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Postavke aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Pozadinski podaci"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Omogućite prijenos podataka na mobilnoj mreži u pozadini"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Za ograničenje pozad. podataka ove aplikacije prvo postavite ogranič. mob. podataka."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Ograničiti podatke u pozadini?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Ova funkcija može uzrokovati da aplikacija koja ovisi o pozadinskim podacima prestane raditi kada su dostupne samo mobilne mreže.\n\nPrikladnije kontrole za prijenos podataka možete pronaći među postavkama koje su dostupne unutar aplikacije."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Ograničavanje prijenosa pozadinskih podataka moguće je samo ako ste postavili ograničenje za prijenos podataka na mobilnoj mreži."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Uklj. autom. sinhron. podataka?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="6387714350903085918">"Promjene računa koje unesete na webu automatski će se kopirati na tablet.\n\nNeki računi također mogu automatski kopirati promjene s tableta na web. Google račun funkcionira na ovaj način."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="6457107552266187107">"Promjene računa koje unesete na webu automatski će se kopirati na telefon.\n\nNeki računi također mogu automatski kopirati promjene s telefona na web. Google račun funkcionira na ovaj način."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Isključiti automatsko sinhroniziranje podataka?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Ovim će se uštedjeti na prijenosu podataka i potrošnji baterije, ali ćete morati ručno sinhronizirati svaki račun da prikupite najnovije informacije. Također, nećete primati obavještenja kada se izvrše ažuriranja."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Datum poništavanja ciklusa potrošnje"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Datum svakog mjeseca:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Postavi"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Postavite upozorenje o prijenosu podataka"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Postavite ograničenje prijenosa podataka"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Ograničavanje prijenosa podataka"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="6000062970083379466">"Vaš tablet će isključiti prijenos podataka na mobilnoj mreži nakon što dostigne ograničenje koje ste postavili.\n\nS obzirom na to da vaš telefon mjeri prijenos podataka te da obračun vašeg operatera može biti drugačiji, uzmite u obzir postavljanje umjerenog ograničenja."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="4942895670789168024">"Vaš telefon će isključiti prijenos podataka na mobilnoj mreži nakon što dostigne ograničenje koje ste postavili.\n\nS obzirom na to da vaš telefon mjeri prijenos podataka te da obračun vašeg operatera može biti drugačiji, uzmite u obzir postavljanje umjerenog ograničenja."</string>
    <string name="data_usage_restrict_background_title" msgid="2745551538820692821">"Ograničiti podatke u pozadini?"</string>
    <string name="data_usage_restrict_background" msgid="1893102079135282794">"Ako ograničite prijenos pozadinskih mobilnih podataka, neke aplikacije i usluge neće raditi ukoliko niste povezani na WiFi mrežu."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="5588623586867665419">"Ako ograničite prijenos pozadinskih mobilnih podataka, neke aplikacije i usluge neće raditi ukoliko niste povezani na WiFi mrežu.\n\nOva postavka utiče na sve korisnike registrirane na ovom tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="6402714504088590463">"Ako ograničite prijenos pozadinskih mobilnih podataka, neke aplikacije i usluge neće raditi ukoliko niste povezani na WiFi mrežu.\n\nOva postavka utiče na sve korisnike registrirane na ovom telefonu."</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"upozorenje"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><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="9065885396147675694">"Uklonjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Uklonjene aplikacije i korisnici"</string>
    <string name="data_usage_received_sent" msgid="1486740779864806124">"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="2695893609573024612">"<xliff:g id="RANGE">%2$s</xliff:g>: iskorišteno otprilike <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="45300375132284265">"<xliff:g id="RANGE">%2$s</xliff:g>: iskoristili ste oko <xliff:g id="TOTAL">%1$s</xliff:g> prema mjerenju tableta. Obračun operatera može biti drugačiji."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="3183594094081558193">"<xliff:g id="RANGE">%2$s</xliff:g>: iskoristili ste oko <xliff:g id="TOTAL">%1$s</xliff:g> prema mjerenju telefona. Obračun operatera može biti drugačiji."</string>
    <string name="data_usage_metered_title" msgid="6421347352444253058">"Mrežna ograničenja"</string>
    <string name="data_usage_metered_body" msgid="1206840367501998582">"Mreže s naplatom tretiraju se kao mobilne mreže kada je ograničeno korištenje podataka u pozadini. Aplikacije mogu dati upozorenje prije korištenja takvih mreža za velika preuzimanja."</string>
    <string name="data_usage_metered_mobile" msgid="3514227339274396401">"Mobilne mreže"</string>
    <string name="data_usage_metered_wifi" msgid="4807465959110473407">"WiFi mreže s naplatom"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="4664158157415362613">"Da odaberete mreže s naplatom, uključite WiFi."</string>
    <string name="data_usage_metered_auto" msgid="1560514082131687116">"Automatski"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Korištenje mreže"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"S naplatom"</string>
    <string name="data_usage_metered_no" msgid="1685828958417926268">"Bez naplate"</string>
    <string name="data_usage_disclaimer" msgid="3271450299386176770">"Obračun podataka operatera može se razlikovati od obračuna vašeg uređaja."</string>
    <string name="cryptkeeper_emergency_call" msgid="8369322820475703306">"Poziv za hitne slučajeve"</string>
    <string name="cryptkeeper_return_to_call" msgid="3857250752781151232">"Vrati se na poziv"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Naziv"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Vrsta"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa servera"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP šifriranje (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP tajna"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Unaprijed dijeljeni IPSec ključ"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec korisnički certifikat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec CA certifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec certifikat servera"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Prikaži napredne opcije"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Domene DNS pretraživanja"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS serveri (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Rute prosljeđivanja (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Korisničko ime"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Lozinka"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Sačuvajte informacije o računu"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ne koristi se)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ne verifikuj server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(primljeno od servera)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Ova vrsta VPN-a ne može biti stalno povezana"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Uvijek aktivni VPN podržava samo numeričke adrese servera"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"DNS server mora biti naveden za uvijek aktivni VPN"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Adrese DNS servera moraju biti numeričke za uvijek aktivni VPN"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Unesena informacija ne podržava uvijek aktivni VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Otkaži"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Odbaci"</string>
    <string name="vpn_save" msgid="683868204634860888">"Sačuvaj"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Poveži se"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Zamijeni"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Uredite VPN profil"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Zaboravi"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Poveži se na <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Želite li prekinuti vezu s ovim VPN-om?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Prekini vezu"</string>
    <string name="vpn_version" msgid="41856553718304367">"Verzija <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Zaboravi VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Želite li zamijeniti postojeći VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Želite li postaviti uvijek uključen VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Kada se uključi ova postavka, nećete imati internetsku mrežu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Vaš postojeći VPN će se zamijeniti i nećete imati internetsku vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Već ste povezani na \"uvijek uključen\" VPN. Ako se povežete na drugu mrežu, vaša postojeća VPN će biti zamijenjena, a način rada \"uvijek uključeno\" će se isključiti."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Već ste povezani na VPN. Ako se povežete na drugu, postojeći VPN će biti zamijenjen."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Uključi"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> se ne može povezati"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Ova aplikacija ne podržava uvijek aktivni VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Dodaj VPN profil"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Uredi profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Izbriši profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Uvijek aktivni VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nije dodan nijedan VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Ostanite stalno povezani na VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Ova aplikacija ne podržava ovu funkciju"</string>
    <string name="vpn_always_on_summary_active" msgid="2532123735674813569">"Funkcija Uvijek uključeno je aktivna"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokiraj veze bez VPN-a"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Treba li zahtijevati VPN vezu?"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Odaberite VPN profil s kojim će uvijek biti uspostavljena veza. Mrežni saobraćaj će biti dopušten samo kad je uspostavljena veza s tim VPN-om."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Ništa"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Uvijek aktivni VPN zahtijeva IP adresu i za server i za DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nema mrežne veze. Pokušajte ponovo kasnije."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Isključeni ste iz VPN-a"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Ništa"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Nedostaje certifikat. Pokušajte urediti profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Korisnik"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Onemogući"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Omogući"</string>
    <string name="trusted_credentials_remove_label" msgid="8975881053042174913">"Ukloni"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Povjerenje"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Omogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Onemogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Trajno ukloniti korisnički CA certifikat?"</string>
    <string name="credential_contains" msgid="407972262032275476">"Ovaj unos sadrži:"</string>
    <string name="one_userkey" msgid="4417212932385103517">"jedan korisnički ključ"</string>
    <string name="one_usercrt" msgid="1865069301105101370">"jedan korisnički certifikat"</string>
    <string name="one_cacrt" msgid="7467796501404158399">"jedan CA certifikat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA certifikati"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detalji o akreditivima"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Uklonjeni akreditiv: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nije instaliran nijedan korisnički akreditiv"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Provjera pravopisa"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Provjera pravopisa za posao"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Ovdje unesite trenutnu lozinku za sigurnosnu kopiju čitavog sistema"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Ovdje unesite novu lozinku za sigurnosne kopije čitavog sistema"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Ovdje ponovo unesite novu lozinku za sigurnosnu kopiju čitavog sistema"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Postavi lozinku za sigurnosnu kopiju"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Otkaži"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Dodatna ažuriranja sistema"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Mreža može biti nadzirana"</string>
    <string name="done_button" msgid="6269449526248267">"Gotovo"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="5491460811755938449">
      <item quantity="one"> Vjerujte certifikatu ili ga uklonite</item>
      <item quantity="few"> Vjerujte certifikatima ili ih uklonite</item>
      <item quantity="other"> Vjerujte certifikatima ili ih uklonite</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="2788832560436163252">
      <item quantity="one"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instalirala certifikate ovlaštenja na vaš uređaj, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="few"> Domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirale certifikate ovlaštenja na vaš uređaj, koji im mogu omogućiti da prate mrežne aktivnosti vašeg uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="other"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instaliralo certifikate ovlaštenja na vaš uređaj, koji im mogu omogućiti da prate mrežne aktivnosti vašeg uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="3989916958347169622">
      <item quantity="one"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instalirala certifikate ovlaštenja za vaš radni profil, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="few"> Domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirale certifikate ovlaštenja za vaš radni profil, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="other"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instaliralo certifikate ovlaštenja za vaš radni profil, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Treća strana je u stanju da prati vaše mrežne aktivnosti, uključujući e-poruke, aplikacije i sigurne web lokacije. \n\nPouzdani akreditiv instaliran na vašem uređaju to omogućava."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="125941406175485894">
      <item quantity="one">Provjerite certifikate</item>
      <item quantity="few">Provjerite certifikate</item>
      <item quantity="other">Provjerite certifikate</item>
    </plurals>
    <string name="user_settings_title" msgid="6550866465409807877">"Više korisnika"</string>
    <string name="user_settings_footer_text" product="device" msgid="7523914344521302179">"Dijelite svoj uređaj dodavanjem novih korisnika. Svaki korisnik na vašem uređaju ima lični prostor za prilagođene početne ekrane, račune, aplikacije, postavke i još mnogo toga."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="3730074318510244552">"Dijelite svoj tablet tako što ćete dodati nove korisnike. Svaki korisnik na vašem tabletu ima lični prostor za prilagođene početne ekrane, račune, aplikacije, postavke i još mnogo toga."</string>
    <string name="user_settings_footer_text" product="default" msgid="4420915712050349125">"Dijelite svoj telefon dodavanjem novih korisnika. Svaki korisnik na vašem telefonu ima lični prostor za prilagođene početne ekrane, račune, aplikacije, postavke i još mnogo toga."</string>
    <string name="user_list_title" msgid="1387379079186123404">"Korisnici i profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Dodaj korisnika ili profil"</string>
    <string name="user_add_user_menu" msgid="6395904234221724625">"Dodaj korisnika"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Ograničeni profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nije postavljeno"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Nije postavljen – Ograničeni profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nije postavljen – Radni profil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="5739771048517070983">"Možete dodati do <xliff:g id="USER_COUNT">%1$d</xliff:g> korisnika"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="3405022988077682357">"Samo vlasnik tableta može upravljati korisnicima."</string>
    <string name="user_cannot_manage_message" product="default" msgid="6434662649769855494">"Samo vlasnik telefona može upravljati korisnicima."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Ograničeni profili ne mogu dodati račune"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Izbrišite <xliff:g id="USER_NAME">%1$s</xliff:g> sa uređaja"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Postavke zaključavanja ekrana"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Dodavanje korisnika sa zaključanog ekrana"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Želite li izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Izbrisati ovog korisnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Ukloniti ovaj profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Ukloniti profil za Work?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="439222554798995592">"Izgubit ćete svoj prostor i podatke sa ovog tableta. Ne možete poništiti ovu akciju."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5991495192044543230">"Izgubit ćete svoj prostor i podatke sa ovog telefona. Ne možete poništiti ovu akciju."</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Sve aplikacije i podaci sa ovog profila će biti izbrisani ako nastavite."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Dodavanje novog korisnika…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Izbriši korisnika"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Izbriši"</string>
    <string name="user_guest" msgid="4545590092001460388">"Gost"</string>
    <string name="user_clear_guest_menu" msgid="4864362688187480452">"Obriši podatke gosta"</string>
    <string name="user_exit_guest_menu" msgid="5064400453222497734">"Završi sesiju gosta"</string>
    <string name="user_exit_guest_confirm_title" msgid="7526978959527761497">"Završiti sesiju gosta?"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Sve aplikacije i podaci iz ove sesije će biti izbrisani."</string>
    <string name="user_exit_guest_dialog_remove" msgid="8095094235815676847">"Završi sesiju"</string>
    <string name="user_enable_calling" msgid="264875360626905535">"Uključi telefonske pozive"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Uključi telefonske pozive i SMS-ove"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Izbriši korisnika"</string>
    <string name="user_enable_calling_confirm_title" msgid="7868894792723368364">"Uključiti telefonske pozive?"</string>
    <string name="user_enable_calling_confirm_message" msgid="4924965198409050155">"Historija poziva će se dijeliti s ovim korisnikom."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Uključiti telefonske pozive i SMS-ove?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Historija poziva i SMS-ova će se dijeliti s ovim korisnikom."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informacije za hitne slučajeve"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informacije i kontakti za korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Odobrenja za aplikaciju i sadržaj"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikacije s ograničenjima"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Proširi postavke za aplikaciju"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Beskontaktna plaćanja"</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Način funkcioniranja"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Plaćajte telefonom u trgovinama"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Zadana aplikacija za plaćanje"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nije postavljeno"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="788899906312142803">"Koristi zadanu aplikaciju"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Uvijek"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Osim kada je otvorena druga aplikacija za plaćanje"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Na terminalu za beskontaktno plaćanje, platite koristeći:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Plaćanje na terminalu"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Postavite aplikaciju za plaćanje, zatim jednostavno prislonite poleđinu svog telefona uz bilo koji terminal označen simbolom beskontaktnog povezivanja."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Razumijem"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Više…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Postavite zadanu aplikaciju za plaćanje"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Ažurirajte zadanu aplikaciju za plaćanje"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Na terminalu za beskontaktno plaćanje, platite koristeći aplikaciju <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Na terminalu za beskontaktno plaćanje, platite koristeći aplikaciju <xliff:g id="APP_0">%1$s</xliff:g>.\n\nTime se zamjenjuje aplikacija <xliff:g id="APP_1">%2$s</xliff:g> kao zadana aplikacija za plaćanje."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Postavi zadano"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Ažuriraj"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Ograničenja"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Ukloni ograničenja"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Promijeni PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Pomoć i pov. inform."</string>
    <string name="support_summary" msgid="1034146931237148885">"Članci za pomoć, telefon i chat, početak"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Račun za sadržaj"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID fotografije"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Ekstremne prijetnje"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Primite upozorenja o ekstremnim prijetnjama po život i imovinu"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ozbiljne prijetnje"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Primi upozorenja o ozbiljnim prijetnjama po život i imovinu"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER upozorenja"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Prijem objava o otmicama djece"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Ponovi"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Omogući Upravitelj pozivima"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Dozvoli ovoj usluzi da upravlja upućivanjem poziva."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Upravitelj za pozive"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Hitna upozorenja putem bežične mreže"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Mrežni operateri"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Nazivi pristupnih tačaka"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Napredno pozivanje"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Pozivanje putem 4G mreže"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="6776190202179584104">"Koristite LTE usluge za poboljšanje glasovne i drugih komunikacija (preporučeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="7814006095552641136">"Koristite usluge 4G mreže za poboljšanje glasovne i drugih komunikacija (preporučeno)"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Pošalji kontakte mobilnom operateru"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Pošaljite brojeve telefona svojih kontakata da omogućite poboljšane funkcije"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Poslati kontakte mobilnom operateru <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Poslati kontakte vašem mobilnom operateru?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Brojevi telefona vaših kontakata periodično će se slati mobilnom operateru <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Pomoću ovih informacija utvrđuje se da li vaši kontakti mogu koristiti određene funkcije, kao što su video pozivi ili neke funkcije za razmjenu poruka."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Brojevi telefona vaših kontakata periodično će se slati vašem mobilnom operateru.<xliff:g id="EMPTY_LINE">

</xliff:g>Pomoću ovih informacija utvrđuje se da li vaši kontakti mogu koristiti određene funkcije, kao što su video pozivi ili neke funkcije za razmjenu poruka."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Preferirana vrsta mreže"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (preporučeno)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS poruke"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Slanje i primanje podataka kada je prijenos podataka na mobilnoj mreži isključen"</string>
    <string name="data_during_calls_title" msgid="3940276893360429144">"Prijenos podataka tokom poziva"</string>
    <string name="data_during_calls_summary" msgid="2289050189544214759">"Dozvolite da se ova SIM kartica koristi samo za prijenos podataka na mobilnoj mreži tokom poziva"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM za Work"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Aplikacija i pristup sadržaju"</string>
    <string name="user_rename" msgid="8735940847878484249">"PROMIJENI NAZIV"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Postavi ograničenja za aplikacije"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontroliše <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Ova aplikacija može pristupiti vašim računima"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Ova aplikacija može pristupati vašim računima. Kontrolu vrši <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"WiFi i mobilne mreže"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Dozvoli izmjenu postavki za WiFi i mobilne mreže"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Dozvoli izmjenu Bluetooth uparivanja i postavki"</string>
    <string name="restriction_nfc_enable_title" msgid="525512312298242911">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="8065688740509581028">"Dozvolite razmjenu podataka kada <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dodirne drugi NFC uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="6397567147629410131">"Dozvolite razmjenu podataka kada tablet dodirne drugi uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="3331800894734678808">"Dozvolite razmjenu podataka kada telefon dodirne drugi uređaj"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Omogućava da aplikacije koriste informacije o lokaciji"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Nazad"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Naprijed"</string>
    <string name="wizard_finish" msgid="4220258401946825946">"Kraj"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_setup_wizard_title" msgid="3945520353564138219">"SIM kartice"</string>
    <string name="sim_settings_title" msgid="8392862852842113531">"SIM kartice"</string>
    <string name="sim_settings_summary" msgid="5777472623476930332">"<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="7726897488921853655">"SIM kartice su promijenjene"</string>
    <string name="sim_cards_changed_message_summary" msgid="7338082681445213621">"Dodirnite za podešavanje aktivnosti"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Prijenos podataka na mobilnoj mreži je nedostupan"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Dodirnite za odabir SIM-a za prijenos podataka"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Uvijek koristi ovo za pozive"</string>
    <string name="select_sim_for_data" msgid="1577092784244587369">"Odaberite SIM za podatke"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Odaberite SIM za SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Prebacivanje SIM-a za prijenos podataka. Ovo može potrajati najviše jednu minutu…"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Poziv putem"</string>
    <string name="sim_select_card" msgid="1226182454109919045">"Odaberite SIM karticu"</string>
    <string name="sim_card_number_title" msgid="4728780444646439845">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_editor_name" msgid="5900178038499314621">"Ime SIM-a"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Unesite ime SIM-a"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM slot %1$d"</string>
    <string name="sim_editor_carrier" msgid="2424593350691002557">"Operater"</string>
    <string name="sim_editor_number" msgid="3209002966895156006">"Broj"</string>
    <string name="sim_editor_color" msgid="9067029630083892961">"Boja SIM-a"</string>
    <string name="sim_card_select_title" msgid="8146523005929848793">"Odaberite SIM karticu"</string>
    <string name="color_orange" msgid="216547825489739010">"Narandžasta"</string>
    <string name="color_purple" msgid="6603701972079904843">"Ljubičasta"</string>
    <string name="sim_no_inserted_msg" msgid="7272710974813741735">"SIM kartica nije umetnuta"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Status SIM-a"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Status SIM-a (utor za sim %1$d)"</string>
    <string name="sim_call_back_title" msgid="4274099761123657464">"Uzvrati poziv putem zadanog SIM-a"</string>
    <string name="sim_outgoing_call_title" msgid="7759080345748128897">"SIM za odlazne pozive"</string>
    <string name="sim_other_call_settings" msgid="5956308869284958883">"Ostale postavke poziva"</string>
    <string name="preferred_network_offload_title" msgid="6453199586512609557">"Pron. preferiranih mreža"</string>
    <string name="preferred_network_offload_header" msgid="4842188794016376899">"Onem. emit. imena mreže"</string>
    <string name="preferred_network_offload_footer" msgid="374984523082849648">"Funkcija Onemogući emitiranje imena mreže sprečava da treće strane dobiju informacije o vašoj mreži."</string>
    <string name="preferred_network_offload_popup" msgid="3949937898807213370">"Onemogućavanje emitiranja imena mreže će spriječiti automatsko povezivanje na skrivene mreže."</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<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="584752983048661108">"SIM kartice promijenjene."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Dodirnite za postavke"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Pitaj svaki put"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Potreban odabir"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Odabir SIM-a"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Postavke"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="6585075562837786847">
      <item quantity="one">Prikaži %d skrivenu stavku</item>
      <item quantity="few">Prikaži %d skrivene stavke</item>
      <item quantity="other">Prikaži %d skrivenih stavki</item>
    </plurals>
    <string name="network_dashboard_title" msgid="788543070557731240">"Mreža i internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="4020746665765996480">"mobilna mreža"</string>
    <string name="network_dashboard_summary_data_usage" msgid="2531133412846140766">"prijenos podataka"</string>
    <string name="network_dashboard_summary_hotspot" msgid="3798394197274240682">"pristupna tačka"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Povezani uređaji"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, način rada za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, način rada za vožnju"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, način rada za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, način rada za vožnju"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nije dostupno jer je NFC isključen"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Da koristite, najprije instalirajte aplikaciju za plaćanje"</string>
    <string name="app_and_notification_dashboard_title" msgid="2861781687031832943">"Aplikacije i obavještenja"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedavne aplikacije, zadane aplikacije"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Pristup obavještenjima nije dostupan za aplikacije u novom radnom profilu."</string>
    <string name="account_dashboard_title" msgid="2735150283267749852">"Računi"</string>
    <string name="account_dashboard_default_summary" msgid="2025250151574540063">"Nije dodan nijedan račun"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Zadane aplikacije"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Jezici, pokreti, vrijeme, sigurnosna kopija"</string>
    <string name="search_results_title" msgid="3360639917793022533">"Postavke"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, veza s mrežom, internet, bežično, podaci, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"WiFi obavještenje, wifi obavještenje"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"prijenos podataka"</string>
    <string name="keywords_vibrate_on_touch" msgid="8379369786860641429">"Zaustavi vibriranje, dodir, tastaturu"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Koristi 24-satni format"</string>
    <string name="keywords_storage_files" msgid="4509695858659705198">"Preuzmi"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Otvori koristeći"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikacije"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"vremenska zona"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Skočni prozor za chat, sistem, obavještenje, prozor, dijalog, ekran, prikazivanje preko drugih aplikacija, crtanje"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Svjetiljka, svjetlo, lampa"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, aktivacija/deaktivacija, kontrola"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilni, mobilni operater, bežični, podaci, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, pozovi, pozivanje"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekran, osjetljiv na dodir"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"zatamnjeni ekran, osjetljiv na dodir, baterija, svijetlo"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"zatamnjeni ekran, noć, boja, noćna smjena, osvjetljenje, boja ekrana, boja"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"pozadina, personalizirati, prilagoditi ekran"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"veličina teksta"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projiciranje, emitiranje, preslikavanje ekrana, dijeljenje ekrana, preslikavanje, dijeli ekran, emitiranje ekrana"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"prostor, disk, čvrsti disk, upotreba uređaja"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"potrošnja energije, punjenje"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pravopis, rječnik, provjera pravopisa, automatsko ispravljanje"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"prepoznavač, ulaz, govor, govoriti, jezik, rad bez dodira, prepoznavanje, uvredljivo, riječ, zvuk, istorija, bluetooth slušalice"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"stopa, jezik, zadano, govori, govoriti, tts, pristupačnost, čitač ekrana, slijepi"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"sat, vojni"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetirati, vratiti, fabričke postavke"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"uništiti, izbrisati, vratiti, obrisati, ukloniti, vratiti na fabričke postavke"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"štampač"</string>
    <string name="keywords_sounds" msgid="1850691834585575875">"zvuk sa zvučnika, zvučnik, jačina zvuka, isključenje zvuka, tišina, zvučni zapis, muzika"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ne ne uznemiravaj, prekinuti, prekidanje, pauza"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"u blizini, lokacija, historija, izvještavanje, GPS"</string>
    <string name="keywords_accounts" msgid="3482052586502133909">"račun, dodavanje računa, radni profil, dodaj račun"</string>
    <string name="keywords_users" msgid="3497517660077620843">"ograničenje, ograničavanje, ograničen"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"korekcija teksta, ispravan, zvuk, vibrirati, auto, jezik, gest, predložiti, prijedlog, tema, uvredljivo, riječ, vrsta, emoji, međunarodna"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"ponovo podesi, željene postavke, zadano"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplikacije, preuzimanje, aplikacije, sistem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikacije, odobrenja, sigurnost"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikacije, zadane"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorirati optimizacije, doziranje, stanje mirovanja aplikacije"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"jarke, RGB, sRGB, boja, prirodno, standardo"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"boja, temperatura, D65, D73, bijela, žuta, plava, topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"prevuci za otključavanje, lozinka, uzorak, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"kačenje ekrana"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"poslovni izazov, rad, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"radni profil, upravljani profil, ujediniti, ujedinjenje, rad, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"pokreti"</string>
    <string name="keywords_cards_passes" msgid="4798102029412153067">"kartice, propusnice"</string>
    <string name="keywords_device_controls" msgid="8962494082504033651">"kontrole uređaja, kontrole"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"plati, dodir, plaćanja"</string>
    <string name="keywords_backup" msgid="707735920706667685">"sigurnosna kopija"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"pokret"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"lice, otključaj, autentifikacija, prijava"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl verzija, imei sv"</string>
    <string name="keywords_sim_status" msgid="8784456547742075508">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, vrsta mobilne mreže, roming, iccid, eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serijski broj, verzija hardvera"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nivo sigurnosne zakrpe za android, verzija nemoduliranog signala, osnovna verzija"</string>
    <string name="keywords_dark_ui_mode" msgid="6465231409128452489">"tema, svijetlo, tamno, način"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tamna tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"greška"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambijentalni prikaz, Prikaz zaključavanja ekrana"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"obavještenja na zaključanom ekranu, obavještenja"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"lice"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"otisak prsta, dodati otisak prsta"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"zatamnjenje ekrana, ekran osjetljiv na dodir, baterija, pametna osvijetljenost, dinamička osvijetljenost, automatska osvijetljenost"</string>
    <string name="keywords_display_adaptive_sleep" msgid="8003895686008403685">"zatamni ekran, stanje mirovanja, baterija, istek vremena, pažnja, prikaz, ekran, neaktivnost"</string>
    <string name="keywords_auto_rotate" msgid="7914655570000378975">"rotirati, obrnuti, rotacija, uspravno, vodoravno, orijentacija, vertikalno, horizontalno"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"nadograditi, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, raspored, obavještenja, blokirati, tišina, vibriranje, stanje mirovanja, rad, fokusiranje, zvuk, isključenje zvuka, dan, radni dan, vikend, radni dan uvečer, događaj"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"ekran, vrijeme zaključavanja, istek vremena, zaključani ekran"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memorija, keš memorija, podaci, izbrisati, obrisati, osloboditi, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"povezan, uređaj, slušalice, slušalice s mikrofonom, zvučnik, bežično, uparivanje, slušalice za umetanje u uho, muzika, medij"</string>
    <string name="keywords_wallpaper" msgid="6712776876474488023">"pozadina, ekran, zaključani ekran, tema"</string>
    <string name="keywords_styles" msgid="6312134005271042434">"oblik ikone, boja za isticanje, font"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"zadani, asistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"plaćanje, zadano"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"dolazno obavještenje"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"povezivanje putem usb uređaja, povezivanje putem bluetooth uređaja, wifi pristupna tačka"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptička tehnologija, vibriranje, ekran, osjetljivost"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"haptička tehnologija, vibriranje, telefon, poziv, osjetljivost, zvono"</string>
    <string name="keywords_notification_vibration" msgid="9162262178415439951">"haptička tehnologija, vibriranje, osjetljivost"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"ušteda baterije, ljepljivo, istrajnost, ušteda energije, baterija"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, raspored, ušteda baterije, ušteda energije, baterija, automatski, procenat"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, napredno pozivanje, 4g pozivanje"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"dodavanje jezika, dodaj jezik"</string>
    <string name="keywords_font_size" msgid="336803136451166298">"veličina teksta"</string>
    <string name="default_sound" msgid="6604374495015245195">"Podrazumijevani zvuk"</string>
    <string name="sound_settings_summary" msgid="944761906531715109">"Zvuk zvona i obavještenja postavljen je na <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Jačina zvuka, vibracija, Ne ometaj"</string>
    <string name="sound_settings_summary_vibrate" msgid="7192223433295988890">"Zvono je postavljeno da vibrira"</string>
    <string name="sound_settings_summary_silent" msgid="746662794579344761">"Zvono je utišano"</string>
    <string name="sound_settings_example_summary" msgid="8125110691864707925">"Zvuk zvona i obavještenja postavljen je na 80%"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Jačina zvuka medija"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Jačina zvuka emitiranja"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Jačina zvuka tokom poziva"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Jačina zvuka alarma"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Jačina zvuka zvona i obavještenja"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Jačina zvuka za obavještenja"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Melodija zvona telefona"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Zadani zvuk obavještenja"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvuk iz aplikacije"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Zadani zvuk obavještenja"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Zadani zvuk alarma"</string>
    <string name="vibrate_when_ringing_title" msgid="3436203665622843196">"Vibriranje za pozive"</string>
    <string name="keywords_vibrate_for_calls" msgid="1019870409730074899">"Vibracija"</string>
    <string name="vibrate_when_ringing_option_never_vibrate" msgid="6518980907289156517">"Bez vibracije"</string>
    <string name="vibrate_when_ringing_option_always_vibrate" msgid="968652667232075466">"Uvijek vibriraj"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Prvo vibriraj, a zatim postepeno zvoni"</string>
    <string name="other_sound_settings" msgid="5468360269346162072">"Drugi zvukovi"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonovi tastature telefona"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvuk zaključavanja ekrana"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvukovi/vibracija prilikom punjenja"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvukovi priključne stanice"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Zvukovi dodira"</string>
    <string name="vibrate_on_touch_title" msgid="9105544449810547716">"Vibracija pri dodiru"</string>
    <string name="vibrate_on_touch_summary" msgid="664831333409399440">"Haptičke povratne informacije za dodir, tastaturu i drugo"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Zvučnik priključne stanice reprodukuje zvuk"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Svi zvukovi"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Samo zvukovi medijskih sadržaja"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Tišina"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonovi"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibracije"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Uključivanje zvukova"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Automatski titlovi"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatski titluj medije"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Nema}=1{Postavljen je 1 raspored}one{Postavljen je # raspored}few{Postavljena su # rasporeda}other{Postavljeno je # rasporeda}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ne ometaj"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Primajte obavještenja samo od važnih osoba i aplikacija"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Ograničite ometanja"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Uključi način rada Ne ometaj"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Zvuci alarma i medija mogu prekinuti"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Rasporedi"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Izbrišite rasporede"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Izbriši"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Uredi"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Rasporedi"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Raspored"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Raspored"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Utišaj telefon u određeno vrijeme"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Postavite pravila za način rada Ne ometaj"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Raspored"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Koristi raspored"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Dozvoli ometanja koja proizvode zvuk"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokiranje vizuelnih ometanja"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Dozvolite vizualnu signalizaciju"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opcije prikaza za skrivena obavještenja"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kada je uključena funkcija Ne ometaj"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Obavještenja bez zvuka"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Obavještenja ćete vidjeti na ekranu"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Telefon neće zvoniti ili vibrirati kada stignu nova obavještenja."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Obavještenja bez vizuelnih elemenata ili zvuka"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Obavještenja nećete vidjeti niti čuti"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="4314772315731485747">"U slučaju novih ili postojećih obavještenja, vaš telefon ih neće prikazivati, neće vibrirati niti zvoniti. Imajte na umu da će se kritična obavještenja o aktivnosti i statusu telefona i dalje pojavljivati.\n\nKada isključite funkciju Ne ometaj, propuštena obavještenja ćete pronaći prevlačenjem s vrha ekrana prema dolje."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Prilagođeno"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Omogući prilagođenu postavku"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Ukloni prilagođenu postavku"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Obavještenja bez zvuka"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Djelimično skriveno"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Obavještenja bez vizuelnih elemenata ili zvuka"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Prilagođena ograničenja"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Isključi zvuk i vibraciju"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Nemoj uključivati ekran"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Nemoj bljeskati"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nemoj isticati obavještenja na ekranu"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Sakrij ikone statusne trake na vrhu ekrana"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Sakrij tačke za obavještenja na ikonama aplikacija"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Nemoj buditi zbog obavještenja"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Sakrij s padajuće trake"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikada"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Zvuk i vibracija"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Zvuk, vibracija i neki vizuelni znakovi obavještenja"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvuk, vibracija i vizuelni znakovi obavještenja"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="1115914818435434668">"Obavještenja koja su potrebna za osnovne radnje i status telefona se nikada neće sakriti."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Ništa"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"druge opcije"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Dodaj"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Uključi"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Uključi sada"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Isključi sada"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Način rada Ne ometaj će biti uključen do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Funkcija Ne ometaj će biti uključena dok je ne isključite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Način rada Ne ometaj je automatski uključen na osnovu rasporeda (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Način rada Ne ometaj je automatski uključila aplikacija (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Način rada Ne ometaj je uključen za <xliff:g id="RULE_NAMES">%s</xliff:g> zajedno sa zadanim postavkama."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="2310353944697868606"><annotation id="link">" Vidi prilagođene postavke"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Samo prioriteti"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<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="4803606180235742003">"Uključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Uključeno"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Pitaj svaki put"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Dok ne isključite"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 sat}one{# sat}few{# sata}other{# sati}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuta}one{# minuta}few{# minute}other{# minuta}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Isključeno}=1{Isključeno/1 raspored se može automatski uključiti}one{Isključeno/# raspored se može automatski uključiti}few{Isključeno/# rasporeda se mogu automatski uključiti}other{Isključeno/# rasporeda se može automatski uključiti}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Šta može prekinuti funkciju Ne ometaj"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Osobe"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikacije"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmi i druga ometanja"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Rasporedi"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Trajanje Brzih postavki"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Kada je uključen način rada Ne ometaj, zvuk i vibracija će biti isključeni, osim za stavke koje omogućite iznad."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Prilagođene postavke"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Pregledajte raspored"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Razumijem"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Obavještenja"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trajanje"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Poruke, događaji i podsjetnici"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Kada je uključen način rada Ne ometaj, zvuk poruka, podsjetnika i događaja će se isključiti, osim za stavke kojim dozvolite iznad. Postavke poruka možete podesiti da omogućite prijateljima, porodici ili drugim kontaktima da vas kontaktiraju."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Gotovo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Postavke"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Obavještenja bez vizuelnih elemenata ili zvuka"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Obavještenja bez zvuka"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Obavještenja nećete vidjeti ili čuti. Dozvoljeni su pozivi od kontakata označenih zvjezdicom i ponovljenih pozivalaca."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Trenutna postavka)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Promijeniti postavke obavještenja načina rada Ne ometaj?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvukovi radnog profila"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Koristi zvukove ličnog profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="4482832555278975008">"Zvukovi su isti za radni i lični profil"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Melodija zvona radnog telefona"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Zadani zvuk radnih obavještenja"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Zadani zvuk radnog alarma"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Isto kao kod ličnog profila"</string>
    <string name="work_sync_dialog_title" msgid="2359563902332046231">"Zamijeniti zvukove?"</string>
    <string name="work_sync_dialog_yes" msgid="9161415252411868574">"Zamijeni"</string>
    <string name="work_sync_dialog_message" msgid="1328692374812258546">"Zvukovi vašeg ličnog profila će se koristi za vaš radni profil"</string>
    <string name="ringtones_install_custom_sound_title" msgid="3885712267015760638">"Želite li dodati prilagođeni zvuk?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="5844996763705884979">"Ovaj fajl će se kopirati u folder <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="26680768777533727">"Melodije zvona"</string>
    <string name="other_sound_category_preference_title" msgid="8182757473602586634">"Ostali zvukovi i vibracije"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Obavještenja"</string>
    <string name="recent_notifications" msgid="1105631022180160436">"Nedavno poslano"</string>
    <string name="recent_notifications_see_all_title" msgid="3087299996651692987">"Pogledajte sve tokom posljednjih 7 dana"</string>
    <string name="advanced_section_header" msgid="6003255455888626056">"Napredno"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Obavještenja za posao"</string>
    <string name="smart_notifications_title" msgid="8995288376897952015">"Prilagodljiva obavještenja"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prilagodljivi prioritet obavještenja"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Obavještenja niskog prioriteta automatski će se postaviti na Diskretno"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Prilagodljivo rangiranje obavještenja"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automatski rangira obavještenja prema relevantnosti"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Povratne informacije o prilagodljivim obavještenjima"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Pokazivanje prilagođavanja obavještenja i prikaz opcije za pružanje povratnih informacija sistemu"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Poništite važnost obavještenja"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Poništite postavke o važnosti koje je promijenio korisnik i dozvolite da asistent za obavještenja određuje prioritete"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Predložene radnje i odgovori"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automatski se prikazuju predložene radnje i odgovori"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Pregledajte nedavna i odgođena obavještenja"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historija obavještenja"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Koristi historiju obavještenja"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Historija obavještenja je isključena"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Uključite historiju obavještenja da vidite nedavna obavještenja i odgođena obavještenja"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nema nedavnih obavještenja"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Vaša nedavna i odgođena obavještenja će se pojaviti ovdje"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"prikaži postavke obavještenja"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"otvaranje obavještenja"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Dozvoli odgađanje obavještenja"</string>
    <string name="hide_silent_icons_title" msgid="5951392023601167577">"Sakrij ikone diskretnih obavještenja"</string>
    <string name="hide_silent_icons_summary" msgid="623763437631637232">"Ikone diskretnih obavještenje nisu prikazane na statusnoj traci"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Tačka za obavještenja na ikoni aplikacije"</string>
    <string name="notification_people_strip_title" msgid="1185857822541001139">"Prikaži nedavne razgovore u traci"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Oblačići"</string>
    <string name="bubbles_feature_education" msgid="4088275802688887634">"Neka obavještenja i drugi sadržaj se mogu prikazati kao oblačići na ekranu. Dodirnite oblačić da ga otvorite. Da ga odbacite, povucite ga prema dolje na ekranu."</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Oblačići"</string>
    <string name="bubbles_conversation_app_link" msgid="5468779786387915337">"Sve postavke oblačića"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Stavi ovaj razgovor u oblačić"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Prikaži plutajuće ikone iznad aplikacija"</string>
    <string name="bubbles_app_toggle_summary" msgid="1574515698567947948">"Dozvoli da aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> prikazuje neka obavještenja kao oblačiće"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Uključiti oblačiće za uređaj?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Ako uključite oblačiće za ovu aplikaciju, također ćete uključiti oblačiće za svoj uređaj.\n\nTo će uticati na druge aplikacije ili razgovore kojima je dozvoljeno otvaranje oblačića."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Uključi"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Otkaži"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Uključeno/Razgovori se mogu pojaviti kao plutajuće ikone"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Dozvoli aplikacijama da prikazuju oblačiće"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Neki razgovori će se pojaviti kao plutajuće ikone iznad drugih aplikacija"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Svi razgovori se mogu prikazivati u oblačićma"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Odabrani razgovori se mogu prikazivati u oblačićima"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Ništa se ne može prikazivati u oblačićima"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Razgovori"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Svi razgovori se mogu pojaviti u oblačiću izuzev"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Isključite oblačiće za ovaj razgovor"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Uključite oblačiće za ovaj razgovor"</string>
    <string name="swipe_direction_title" msgid="4260320464727178413">"Radnje prevlačenja"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Prevucite udesno za odbacivanje, ulijevo za prikaz menija"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Prevucite ulijevo za odbacivanje, udesno za prikaz menija"</string>
    <string name="gentle_notifications_title" msgid="2793492905132530991">"Diskretna obavještenja"</string>
    <string name="gentle_notifications_also_display" msgid="8617545395880297691">"Također prikaži na"</string>
    <string name="gentle_notifications_display_status" msgid="7410244447768694856">"Statusna traka"</string>
    <string name="gentle_notifications_display_lock" msgid="1914245082527924144">"Zaključani ekran"</string>
    <string name="gentle_notifications_education" msgid="5957509621826384362">"Diskretna obavještenja su uvijek nečujna i uvijek se prikazuju na padajućoj traci"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="7616926954719310445">"Prikaži samo na padajućoj traci"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="3936088046873705625">"Prikaži na padajućoj traci i zaključanom ekranu"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="3363137853729359907">"Prikaži na padajućoj traci i statusnoj traci"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="2068738866725616212">"Prikaži na padajućoj traci, statusnoj traci i zaključanom ekranu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Sakrij nečujna obavještenja na statusnoj traci"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Trepćuće svjetlo"</string>
    <string name="lock_screen_notifications_title" msgid="3063951257121435570">"Obavještenja na zaklj. ekranu"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Preskoči zaključani ekran"</string>
    <string name="lockscreen_bypass_summary" msgid="6688592486830491144">"Nakon otključavanja licem idi na posljednji korišteni ekran"</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"zaključaj ekran, zaljučavanje ekrana, preskoči, zaobilaženje"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kada je radni profil zaključan"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Obavještenja na zaključanom ekranu"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Prikaži zadane i nečujne razgovore"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Sakrij nečujne razgovore i obavještenja"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ne prikazuj nikakva obavještenja"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Obavještenja o osjetljivom sadržaju"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Prikazuj osjetljiv sadržaj kada je uređaj zaključan"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Obavještenja o osjetljivom sadržaju radnog profila"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Prikazuj osjetljivi sadržaj radnog profila kada je uređaj zaključan"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Prikaži sav sadržaj obavještenja"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Prikaži osjetljiv sadržaj samo kada je otključano"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Uopće ne prikazuj obavještenja"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Kako želite da se obavještenja prikazuju na zaključanom ekranu?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Zaključani ekran"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Prikaži sav sadržaj obavještenja radnog profila"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Sakrij osjetljivi poslovni sadržaj"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kada je uređaj zaključan, na koji način želite da se prikazuju obavještenja profila?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Obavještenja profila"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Obavještenja"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Obavještenja o aplikaciji"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategorija obavještenja"</string>
    <string name="notification_group_title" msgid="7525666535695631538">"Grupa kategorija obavještenja"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Ponašanje"</string>
    <string name="notification_importance_unspecified" msgid="1543165530748339700">"Dozvoli zvuk"</string>
    <string name="notification_importance_blocked" msgid="4933285639639899394">"Nikad ne prikazuj obavještenja"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Razgovori"</string>
    <string name="conversation_category_title" msgid="6777135786004214149">"Razgovor"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Odjeljak za razgovore"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Dozvolite aplikaciji da koristi odjeljak za razgovor"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nije razgovor"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Ukloni iz odjeljka za razgovor"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Ovo je razgovor"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Dodavanje u odjeljak za razgovor"</string>
    <string name="manage_conversations" msgid="4440289604887824337">"Upravljajte razgovorima"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nema prioritetnih razgovora"</string>
    <plurals name="priority_conversation_count" formatted="false" msgid="4229447176780862649">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> prioritetan razgovor</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> prioritetna razgovora</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> prioritetnih razgovora</item>
    </plurals>
    <string name="important_conversations" msgid="1233893707189659401">"Prioritetni razgovori"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Prikazuju se na vrhu odjeljka za razgovor u vidu plutajućih oblačića"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Prikazuju se na vrhu odjeljka za razgovor"</string>
    <string name="other_conversations" msgid="551178916855139870">"Razgovori koji nisu prioritetni"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Razgovori koje ste mijenjali"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nedavni razgovori"</string>
    <string name="conversation_settings_clear_recents" msgid="4246342656145488662">"Obriši sve nedavno"</string>
    <string name="clear" msgid="5092178335409471100">"Obriši"</string>
    <string name="important_bubble" msgid="7911698275408390846">"Smjesti prioritetne razgovore u oblačiće"</string>
    <string name="important_conversation_behavior_summary" msgid="1845064084071107732">"Prioritetni razgovori se prikazuju na vrhu padajuće trake. Razgovore možete postaviti i u oblačić i prekinuti funkciju Ne ometaj."</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Ovdje će se prikazati prioritetni i promijenjeni razgovori"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Ovdje će se prikazati razgovori koje označite kao prioritetne i na kojima izvršite neke druge promjene. \n\nDa promijenite postavke razgovora: \nprevucite s vrha ekrana prema dolje da otvorite padajuću traku, a zatim dodirnite i zadržite razgovor."</string>
    <string name="notification_importance_min" msgid="4609688642942787774">"Prikaži bez zvuka i minimiziraj"</string>
    <string name="notification_importance_low" msgid="7562535765919565273">"Prikaži bez zvuka"</string>
    <string name="notification_importance_default" msgid="7483906490369073043">"Reproduciraj zvuk"</string>
    <string name="notification_importance_high" msgid="8453789143477210550">"Pusti zvuk i prikaži na ekranu"</string>
    <string name="notification_importance_high_silent" msgid="8977232884004607985">"Prikaži na ekranu"</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimiziraj"</string>
    <string name="notification_importance_low_title" msgid="658158049378796947">"Srednja"</string>
    <string name="notification_importance_default_title" msgid="8875198696330289686">"Visoka"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Prikaži na ekranu"</string>
    <string name="notification_block_title" msgid="7392909527700971673">"Blokiraj"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Nečujno"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Zadano"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Dozvoli ometanja"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"family link da aktivira zvuk, vibrira i/ili prikaže obavještenja na ekranu"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritetni"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Prikazuje se na vrhu odjeljka za razgovor, pojavljuje se kao plutajući oblačić, prikazuje sliku profila na zaključanom ekranu"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> ne podržava većinu funkcija razgovora. Razgovor ne možete postaviti kao prioritetan i razgovori se neće pojavljivati kao plutajući oblačići."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Suzite obavještenja u jedan red na padajućoj traci"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Bez zvuka ili vibracije"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Bez zvuka ili vibracije i pojavljuje se pri dnu odjeljka za razgovor"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Može zvoniti ili vibrirati na osnovu postavki vašeg telefona"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kada je uređaj otključan, vidite obavještenja u vidu banera na vrhu ekrana"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Sva obavještenja iz aplikacije \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Sva obavještenja aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="default_notification_assistant" msgid="243718059890346442">"Prilagodljiva obavještenja"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="1479283620504341566">
      <item quantity="one">~<xliff:g id="NUMBER_1">%d</xliff:g> obavještenje dnevno</item>
      <item quantity="few">~<xliff:g id="NUMBER_1">%d</xliff:g> obavještenja dnevno</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> obavještenja dnevno</item>
    </plurals>
    <plurals name="notifications_sent_weekly" formatted="false" msgid="4913443431857170519">
      <item quantity="one">~<xliff:g id="NUMBER_1">%d</xliff:g> obavještenje sedmično</item>
      <item quantity="few">~<xliff:g id="NUMBER_1">%d</xliff:g> obavještenja sedmično</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> obavještenja sedmično</item>
    </plurals>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikada"</string>
    <string name="manage_notification_access_title" msgid="4714320299084782521">"Pristup obavještenjima"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Pristup obavještenjima radnog profila je blokiran"</string>
    <string name="manage_notification_access_summary_zero" msgid="7528633634628627431">"Aplikacije ne mogu čitati obavještenja"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="3703008881487586312">
      <item quantity="one">%d aplikacija može čitati obavještenja</item>
      <item quantity="few">%d aplikacije mogu čitati obavještenja</item>
      <item quantity="other">%d aplikacija može čitati obavještenja</item>
    </plurals>
    <string name="notification_assistant_title" msgid="6983941403582134437">"Prilagodljiva obavještenja"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Nema"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Nijedna instalirana aplikacija nije zatražila pristup obavještenjima."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Dozvoli pristup obavještenjima"</string>
    <string name="notification_assistant_security_warning_title" msgid="2972346436050925276">"Dozvoliti pristup obavještenjima za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="7362924206925040510">"<xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> će moći čitati sva obavještenja, uključujući lične informacije kao što su imena kontakata i tekst primljenih poruka. Ova aplikacija će također moći odbaciti obavještenja ili djelovati na dugmad u obavještenjima, uključujući odgovaranje na telefonske pozive. \n\nNa ovaj način će se aplikaciji dati i mogućnost da uključi i isključi način rada Ne ometaj te da promijeni postavke povezane s tom opcijom."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Želite li dozvoliti pristup obavještenjima za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1658213659262173405">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> će moći čitati sva obavještenja, uključujući lične informacije kao što su imena kontakata i tekst primljenih poruka. Ova aplikacija će također moći odbaciti obavještenja ili djelovati na dugmad u obavještenjima, uključujući odgovaranje na telefonske pozive. \n\nNa ovaj način će se aplikaciji dati i mogućnost da uključi i isključi način rada Ne ometaj te da promijeni postavke povezane s tom opcijom."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Ako korisniku <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> isključite pristup obavještenjima, može se isključiti i pristup načinu rada Ne ometaj."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Isključi"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Otkaži"</string>
    <string name="notification_listener_type_title" msgid="2791552789364336733">"Dozvoljene vrste obavještenja"</string>
    <string name="notif_type_ongoing" msgid="2295338067608686711">"Važna neprekidna obavještenja"</string>
    <string name="notif_type_conversation" msgid="3014259738224129504">"Obavještenja o razgovorima"</string>
    <string name="notif_type_alerting" msgid="2300039323822104165">"Zvučna obavještenja"</string>
    <string name="notif_type_silent" msgid="2514763073653979199">"Nečujna obavještenja"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Usluge pomagača za VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nijedna instalirana aplikacija nije zatražila da bude pokrenuta kao usluga pomagača za VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Želite li dozvoliti pristup VR-a za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> će moći raditi kada aplikacije budete koristili u načinu rada virtuelne realnosti."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Kada je uređaj u VR načinu rada"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Smanjenje zamućenosti (preporučeno)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Smanjenje treperenja"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Slika u slici"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Nijedna instalirana aplikacija ne podržava način rada Slika u slici"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"sus slika u"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Slika u slici"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Dozvoli način rada Slika u slici"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Dozvolite aplikaciji da kreira prozor u načinu rada slika u slici dok je aplikacija otvorena ili nakon što je napustite (naprimjer, da nastavite gledati videozapis). Ovaj prozor se prikazuje preko drugih aplikacija koje koristite."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Povezane poslovne i lične aplikacije"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Povezano"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nije povezano"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nema povezanih aplikacija"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"više profila povezana aplikacija poslovne i lične aplikacije"</string>
    <string name="interact_across_profiles_app_detail_title" msgid="7776184211173575648">"Povezane poslovne i lične aplikacije"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Povezano"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Poveži ove aplikacije"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Povezane aplikacije dijele odobrenja i mogu pristupati podacima uzajamno."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Povežite aplikacije samo ako ste uvjereni da neće dijeliti lične podatke s vašim IT administratorom."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Možete prekinuti povezanost s aplikacijama bilo kada u postavkama privatnosti uređaja."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Povjeriti lične podatke aplikaciji <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Povežite aplikacije samo ako ste uvjereni da neće dijeliti lične podatke s vašim IT administratorom."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Podaci aplikacije"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Ova aplikacija može pristupiti podacima u vašoj ličnoj aplikaciji <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Odobrenja"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Ova aplikacija može koristiti odobrenja vaše lične aplikacije <xliff:g id="NAME">%1$s</xliff:g>, kao što su pristup lokaciji, pohrani ili kontaktima."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nema povezanih aplikacija"</string>
    <plurals name="interact_across_profiles_number_of_connected_apps" formatted="false" msgid="6991750455661974772">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija je povezana</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aplikacije su povezane</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija je povezano</item>
    </plurals>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Da povežete ove aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na radnom profilu"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Da povežete ove aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na ličnom profilu"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Dodirnite da preuzmete aplikaciju"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Pristup načinu rada Ne ometaj"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Dozvoli način rada Ne ometaj"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nijedna instalirana aplikacija nije zatražila pristup za Ne ometaj"</string>
    <string name="loading_notification_apps" msgid="5139471829295287945">"Učitavanje aplikacija…"</string>
    <string name="app_notifications_off_desc" msgid="6691342160980435901">"Na vaš zahtjev, Android blokira pojavljivanje obavještenja iz ove aplikacije na ovom uređaju"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Na vaš zahtjev, Android blokira pojavljivanje ove kategorije obavještenja na ovom uređaju"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Na vaš zahtjev, Android blokira pojavljivanje ove grupe obavještenja na ovom uređaju"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorije"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Ostalo"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="483490958130993160">
      <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="4716199078612071915">"Ova aplikacija nije objavila nikakva obavještenja"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Dodatne postavke u aplikaciji"</string>
    <string name="notification_screen_summary" msgid="5984915275134654822">"Historija obavještenja, oblačići, nedavno poslano"</string>
    <string name="app_notification_listing_summary_zero" msgid="2988400013221120744">"Uključeno za sve aplikacije"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="1506127395400503717">
      <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="5963473421547029532">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija je izbrisana</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije su izbrisane</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorija je izbrisano</item>
    </plurals>
    <string name="notification_toggle_on" msgid="1624283327379059003">"Uključeno"</string>
    <string name="notification_toggle_off" msgid="3295373308338024844">"Isključeno"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokiraj sve"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Nikada ne prikazuj ova obavještenja"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Prikaži obavještenja"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nikad ne prikazuj obavještenja u nijansi ili na perifernim uređajima"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Dozvoli tačku za obavještenja"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Prikaži tačku za obavještenja"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Zanemari način rada Ne ometaj"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Dozvoli da se obavještenja nastave pojavljivati kada je uključen način rada Ne ometaj"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Zaključani ekran"</string>
    <string name="app_notification_row_banned" msgid="4513523107019706924">"Blokirano"</string>
    <string name="app_notification_row_priority" msgid="8100777138078316446">"Prioritetna"</string>
    <string name="app_notification_row_sensitive" msgid="7374688948587174964">"Osjetljivo"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Gotovo"</string>
    <string name="app_notification_importance_title" msgid="8293193440040799998">"Važnost"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Trepćuće svjetlo"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibracija"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Zvuk"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritetno"</string>
    <string name="notification_conversation_add_to_home" msgid="8136269431130231389">"Dodavanje u dom"</string>
    <string name="zen_mode_rule_delete_button" msgid="7642063606919058862">"Izbriši"</string>
    <string name="zen_mode_rule_rename_button" msgid="4158377587795511144">"Promijeni naziv"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Naziv rasporeda"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Unesite naziv rasporeda"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Naziv rasporeda se već koristi"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Dodajte još"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Dodajte raspored događaja"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Dodaj vremenski određen raspored"</string>
    <string name="zen_mode_delete_rule" msgid="5419296431989891130">"Izbriši raspored"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Odaberite vrstu rasporeda"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Izbrisati pravilo “<xliff:g id="RULE">%1$s</xliff:g>”?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Izbriši"</string>
    <string name="zen_mode_rule_type_unknown" msgid="7819162569994282316">"Nepoznato"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Ove postavke nije moguće sada promijeniti. Aplikacija (<xliff:g id="APP_NAME">%1$s</xliff:g>) je automatski uključila način rada Ne ometaj uz prilagođene postavke."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Ove postavke nije moguće sada promijeniti. Neka aplikacija je automatski uključila način rada Ne ometaj uz prilagođene postavke."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Ove postavke nije moguće sada promijeniti. Način rada Ne ometaj je ručno uključen uz prilagođene postavke."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Vrijeme"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="6534402316741678208">"Automatsko pravilo je postavljeno da se način rada Ne ometaj uključi tokom određenih perioda"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Događaj"</string>
    <string name="zen_event_rule_enabled_toast" msgid="4943723266121388395">"Automatsko pravilo je postavljeno da se način rada Ne ometaj uključi tokom određenih događaja"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Za vrijeme događaja za"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="3065013489987409864">"Za vrijeme događaja za <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="8395450413356855311">"bilo koji kalendar"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="7786137431469077008">"Ako je odgovor <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Bilo koji kalendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Ako je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Da, Možda ili Bez odgovora"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Da ili Možda"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Da"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Pravilo nije pronađeno."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Uključen način rada / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<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="8633770815307716351">"Dani"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Ne postoji"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="1583884351893245169">"Svaki dan"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarm može prekoračiti vrijeme završetka"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Raspored će se isključiti kada se alarm aktivira"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Ponašanje načina rada Ne ometaj"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Koristite zadane postavke"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Kreirajte prilagođene postavke za ovaj raspored"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"\"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="6022314482293187463">"<xliff:g id="START">%1$s</xliff:g> do <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Razgovori"</string>
    <string name="zen_mode_conversations_section_title" msgid="666809483050936026">"Razgovori koji vas mogu prekinuti"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Svi razgovori"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioritetni razgovori"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Nema"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Nema}=1{1 razgovor}one{# razgovor}few{# razgovora}other{# razgovora}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Ko vas može prekinuti"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Pozivi"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Pozivi"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"pozivi"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Pozivi koji vas mogu prekinuti"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Da se uvjerite da ćete čuti dozvoljene pozive, provjerite je li uređaj postavljen da zvoni"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Dolazni pozivi su blokirani za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Postavke možete podesiti da omogućite prijateljima, porodici ili drugim kontaktima da vas kontaktiraju."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontakti označeni zvjezdicom"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Nema}=1{{contact_1}}=2{{contact_1} i {contact_2}}=3{{contact_1}, {contact_2} i {contact_3}}one{{contact_1}, {contact_2} i još # kontakt}few{{contact_1}, {contact_2} i još # kontakta}other{{contact_1}, {contact_2} i još # kontakata}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Bez imena)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Poruke"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"poruke"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Poruke"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Poruke koje vas mogu prekinuti"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Da se uvjerite da ćete čuti dozvoljene poruke, provjerite je li uređaj postavljen da zvoni"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Dolazne poruke su blokirane za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Postavke možete podesiti da prijateljima, porodici ili drugim kontaktima dozvolite da vas kontaktiraju."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Primate sve poruke"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Primate sve pozive"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Nema}=1{1 kontakt}one{# kontakt}few{# kontakta}other{# kontakata}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Svako"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakti"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontakti označeni zvjezdicom"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="8078759939219244001">"Od kontakata označenih zvjezdicom i ponovljenih pozivalaca"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="2276432091940405376">"Od kontakata i ponovljenih pozivalaca"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7748352153193832632">"Samo od ponovljenih pozivalaca"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Ništa"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Ništa"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmi"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Obavještenja tajmera, alarma, sigurnosnih sistema i drugih aplikacija"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmi"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmi"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Zvukovi medija"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Zvukovi iz videozapisa, igara i drugih medija"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"mediji"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Mediji"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Zvukovi dodira"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvukovi tastature i druge dugmadi"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvukovi dodira"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Zvukovi dodira"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Podsjetnici"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Obavještenja o zadacima i podsjetnicima"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"podsjetnici"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Podsjetnici"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Događaji u Kalendaru"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Obavještenja nadolazećih događaja iz kalendara"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"događaji"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Događaji"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Dozvolite aplikacijama da zanemaruju"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikacije koje vas mogu prekinuti"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Odaberite još aplikacija"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nije odabrana nijedna aplikacija"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nijedna aplikacija ne može prekinuti"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Dodajte aplikacije"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Sva obavještenja"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Neka obavještenja"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Odabrane osobe vas i dalje mogu kontaktirati čak i ako ne dozvolite aplikacijama da vas prekidaju"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Nijedna aplikacija ne može prekinuti}=1{Aplikacija {app_1} može prekinuti}=2{Aplikacije {app_1} i {app_2} mogu prekinuti}=3{Aplikacije {app_1}, {app_2} i {app_3} mogu prekinuti}one{Aplikacije {app_1}, {app_2} i još # njih mogu prekinuti}few{Aplikacije {app_1}, {app_2} i još # njih mogu prekinuti}other{Aplikacije {app_1}, {app_2} i još # njih mogu prekinuti}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikacije"</string>
    <string name="zen_mode_bypassing_apps_all_summary" msgid="5197566190120503132">"Sva obavještenja"</string>
    <string name="zen_mode_bypassing_apps_some_summary" msgid="1514572070650411509">"Neka obavještenja"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Obavještenja koja vas mogu prekinuti"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Dozvoli sva obavještenja"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Ništa ne može prekinut}=1{Zvuk {sound_category_1} može prekinuti}=2{Zvukovi {sound_category_1} i {sound_category_2} mogu prekinuti}=3{Zvukovi {sound_category_1}, {sound_category_2} i {sound_category_3} mogu prekinuti}one{Zvukovi {sound_category_1}, {sound_category_2} i još # njih mogu prekinuti}few{Zvukovi {sound_category_1}, {sound_category_2} i još # njih mogu prekinuti}other{Zvukovi {sound_category_1}, {sound_category_2} i još # njih mogu prekinuti}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Ništa ne može prekinuti"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Niko ne može prekinuti"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Neke osobe mogu prekinuti"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Sve osobe mogu prekinuti"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Ponovni pozivaoci"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Dozvoli ponovne pozivaoce"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"bilo ko"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontakti"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontakti označeni zvjezdicom"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"ponovljeni pozivaoci"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> i <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Ako ista osoba ponovo pozove u roku od <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="3126805555852783860">"Prilagođeno"</string>
    <string name="zen_mode_when" msgid="5710214762051824755">"Automatski upaliti"</string>
    <string name="zen_mode_when_never" msgid="2537537280091840672">"Nikad"</string>
    <string name="zen_mode_when_every_night" msgid="9018738747936038166">"Svaku noć"</string>
    <string name="zen_mode_when_weeknights" msgid="531342225633264368">"Večeri radne sedmice"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Vrijeme početka"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Vrijeme završetka"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> sljedeći dan"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Pređi na postavku Samo alarmi na neodređeno vrijeme"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="1900512966361163390">
      <item quantity="one">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> minutu (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> minute (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> minuta (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="955991428001659124">
      <item quantity="one">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> sat do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="few">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> sata do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> sati do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Pređi na postavku Samo alarmi do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Promijeniti u uvijek prekini"</string>
    <string name="zen_mode_screen_on" msgid="7312758100468915319">"Kada je ekran uključen"</string>
    <string name="zen_mode_screen_on_summary" msgid="510055058460316698">"Dopusti da se na ekranu istaknu obavještenja koja su prigušena načinom rada Ne ometaj te da prikažu ikonu na statusnoj traci"</string>
    <string name="zen_mode_screen_off" msgid="7069798697669366075">"Kada je ekran isključen"</string>
    <string name="zen_mode_screen_off_summary" msgid="4698018253505406152">"Dopustite da obavještenja koja su utišana načinom rada Ne ometaj uključe ekran i zatrepere svjetlom"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="1958271859408992636">"Dopustite da obavještenja koja su utišana načinom rada Ne ometaj uključe ekran"</string>
    <string name="notification_app_settings_button" msgid="4692549882609342128">"Postavke za obavještenja"</string>
    <string name="suggestion_button_text" msgid="4370673818678692873">"Uredu"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Zatvori"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Pošalji povr. informacije o uređaju"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Upišite PIN administratora"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Uključeno"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Isključeno"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Kačenje aplikacije"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Kačenje aplikacije omogućava da se trenutna aplikacija zadrži na ekranu dok je ne otkačite. Naprimjer, koristeći ovu funkciju možete omogućiti pouzdanom prijatelju da igra određenu igru."</string>
    <string name="screen_pinning_description" msgid="7289730998890213708">"Kada je aplikacija zakačena, ona može otvoriti druge aplikacije i omogućiti pristup ličnim podacima. \n\nDa koristite kačenje aplikacije: 	\n1.	Uključite kačenje aplikacije 	\n2.	Otvorite Pregled 	\n3.	Dodirnite ikonu aplikacije na vrhu ekrana, a zatim dodirnite Zakači"</string>
    <string name="screen_pinning_guest_user_description" msgid="5826264265872938958">"Kada je aplikacija zakačena, ona može otvoriti druge aplikacije i omogućiti pristup ličnim podacima. \n\nAko želite dijeliti uređaj s nekim na siguran način, pokušajte koristiti profil za gosta korisnika. \n\nDa koristite kačenje aplikacije: 	\n1.	Uključite kačenje aplikacije 	\n2.	Otvorite Pregled 	\n3.	Dodirnite ikonu aplikacije na vrhu ekrana, a zatim dodirnite Zakači"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kada je aplikacija zakačena: \n\n•		Lični podaci mogu biti dostupni \n		(kao što su kontakti i sadržaj e-pošte) \n•		Zakačena aplikacija može otvoriti druge aplikacije \n\nKačenje aplikacije koristite samo s osobama kojima vjerujete."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Traži uzorak za otključavanje prije poništavanja kačenja"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Traži PIN prije poništavanja kačenja"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Traži lozinku prije poništavanja kačenja"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Zaključaj uređaj kada se ekran otkači"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Potvrdite brisanje SIM-a"</string>
    <string name="confirm_sim_deletion_description" msgid="8937609409607338516">"Potvrdite identitet prije potpunog brisanja preuzetog SIM-a"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Ovim profilom za Work upravlja:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Profilom upravlja <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="869354050717870055">"(Eksperimentalno)"</string>
    <string name="encryption_interstitial_header" msgid="4418014339568737685">"Sigurno pokretanje"</string>
    <string name="encryption_continue_button" msgid="3591796237625134622">"Nastavi"</string>
    <string name="encryption_interstitial_message_pin" msgid="1413575143234269985">"Uređaj možete dodatno zaštiti tako što ćete tražiti PIN prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja traži PIN?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="726550613252236854">"Uređaj možete dodatno zaštiti tako što ćete tražiti unošenje uzorka prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja traži unošenje uzorka?"</string>
    <string name="encryption_interstitial_message_password" msgid="6051054565294909975">"Uređaj možete dodatno zaštiti tako što ćete tražiti lozinku prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja traži lozinka?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="7152770518093102916">"Osim korištenja otiska prsta za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja PIN-a prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva PIN?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="6257856552043740490">"Osim korištenja otiska prsta za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja uzorka prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva unošenje uzorka?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="7710804822643612867">"Osim korištenja otiska prsta za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja lozinke prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme.\n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva lozinka?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="8577135499926738241">"Osim otključavanja pomoću lica, uređaj možete dodatno zaštititi zahtjevom za unos PIN-a prije pokretanja. Dok se uređaj ne pokrene, neće se moći primati pozivi, poruke ili obavještenja, uključujući i alarme.\n\nNa ovaj način se štite podaci na izgubljenim ili ukradenim uređajima. Zahtijevati PIN za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="5851725964283239644">"Osim otključavanja pomoću lica, uređaj možete dodatno zaštititi zahtjevom za unos uzorka prije pokretanja. Dok se uređaj ne pokrene, neće se moći primati pozivi, poruke ili obavještenja, uključujući i alarme.\n\nNa ovaj način se štite podaci na izgubljenim ili ukradenim uređajima. Zahtijevati uzorak za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3553329272456428461">"Osim otključavanja pomoću lica, uređaj možete dodatno zaštititi zahtjevom za unos lozinke prije pokretanja. Dok se uređaj ne pokrene, neće se moći primati pozivi, poruke ili obavještenja, uključujući i alarme.\n\nNa ovaj način se štite podaci na izgubljenim ili ukradenim uređajima. Zahtijevati lozinku za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pin_for_biometrics" msgid="4590004045791674901">"Osim korištenja biometrije za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja PIN-a prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme.\n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva PIN?"</string>
    <string name="encryption_interstitial_message_pattern_for_biometrics" msgid="2697768285995352576">"Osim korištenja biometrije za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja uzorka prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme.\n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva uzorak?"</string>
    <string name="encryption_interstitial_message_password_for_biometrics" msgid="1895561539964730123">"Osim korištenja biometrije za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja lozinke prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme.\n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva lozinka?"</string>
    <string name="encryption_interstitial_yes" msgid="1948016725089728181">"Da"</string>
    <string name="encryption_interstitial_no" msgid="3352331535473118487">"Ne"</string>
    <string name="restricted_true_label" msgid="612852292488747564">"Ograničena"</string>
    <string name="restricted_false_label" msgid="2837053797913490628">"Aplikacija može koristiti bateriju u pozadini"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8974156384205924887">"Zahtijevati PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1587587568721873184">"Zahtijevati unos obrasca?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="2701793623210531836">"Zahtijevati lozinku?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="4482887117824444481">"Prilikom unosa PIN-a za pokretanje uređaja, usluge za pristupačnost kao što je <xliff:g id="SERVICE">%1$s</xliff:g> još uvijek neće biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="5156321541636018756">"Prilikom unosa obrasca za pokretanje uređaja, usluge za pristupačnost kao što je <xliff:g id="SERVICE">%1$s</xliff:g> još uvijek neće biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="1917287751192953034">"Prilikom unosa lozinke za pokretanje uređaja, usluge za pristupačnost kao što je <xliff:g id="SERVICE">%1$s</xliff:g> još uvijek neće biti dostupne."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="5766006106305996844">"Napomena: Ako ponovo pokrenete telefon ili postavite zaključavanje ekrana, ova se aplikacija neće moći pokrenuti dok ne otključate telefon"</string>
    <string name="imei_information_title" msgid="8703564992893669514">"Informacije za IMEI"</string>
    <string name="imei_information_summary" msgid="4763358372990258786">"Relativne informacije za IMEI"</string>
    <string name="slot_number" msgid="2663789411468530397">"(<xliff:g id="SLOT_NUM">%1$d</xliff:g>. slot)"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Zadano otvaranje"</string>
    <string name="app_launch_domain_links_title" msgid="6702041169676128550">"Otvaranje linkova"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Otvori podržane linkove"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="3609156836041234957">"Otvori bez pitanja"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podržani linkovi"</string>
    <string name="app_launch_other_defaults_title" msgid="3296350563585863885">"Ostale zadane vrijednosti"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"Iskorišteno <xliff:g id="SIZE">%1$s</xliff:g> (<xliff:g id="STORAGE_TYPE">%2$s</xliff:g>)"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"unutrašnja pohrana"</string>
    <string name="storage_type_external" msgid="125078274000280821">"vanjska pohrana"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"Iskorišt.: <xliff:g id="SIZE">%1$s</xliff:g> od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Iskorištena memorija"</string>
    <string name="change" msgid="273206077375322595">"Izmijeni"</string>
    <string name="change_storage" msgid="8773820275624113401">"Promijeni pohranu"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Obavještenja"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Uključeno"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<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="5603160425378437143">"Isključeno"</string>
    <string name="notifications_partly_blocked" msgid="5738239705473445725">"Isključene kategorije: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="notifications_silenced" msgid="2673798575466545098">"Bez zvuka"</string>
    <string name="notifications_redacted" msgid="8820993927920208612">"Osjetljivi sadržaj nije na zaključanom ekranu."</string>
    <string name="notifications_hidden" msgid="2415415452913806859">"Ne na zaključanom ekranu"</string>
    <string name="notifications_priority" msgid="9068574646650663837">"Način rada Ne ometaj je poništen."</string>
    <string name="notifications_summary_divider" msgid="6877149909390030983">" / "</string>
    <string name="notification_summary_level" msgid="4074326972839105652">"Nivo %d"</string>
    <string name="notification_summary_channel" msgid="8459033623057872803">"<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="1385401442703692986">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija isključena</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije isključene</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorija isključeno</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="5015472550875144481">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dodijeljeno odobrenje</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dodijeljena odobrenja</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dodijeljenih odobrenja</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="2091022049141391855">
      <item quantity="one"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> odobrenja je dato</item>
      <item quantity="few"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> odobrenja su data</item>
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> odobrenja je dato</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="5888624648943937645">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dodatno odobrenje</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dodatna odobrenje</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dodatnih odobrenja</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nema dodijeljenih odobrenja"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nema zatraženih odobrenja"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Kontrolirajte pristup aplikacije podacima"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Sve aplikacije"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Instalirane aplikacije"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Instant aplikacije"</string>
    <string name="filter_notif_all_apps" msgid="2764590815789208306">"Aplikacije: Sve"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Isključeno"</string>
    <string name="filter_notif_urgent_channels" msgid="875381675739324318">"Kategorije: hitno"</string>
    <string name="filter_notif_low_channels" msgid="2163005243095264537">"Kategorije: niska važnost"</string>
    <string name="filter_notif_blocked_channels" msgid="1131444963543380495">"Kategorije: Isključene"</string>
    <string name="filter_notif_dnd_channels" msgid="13445325087914932">"Kategorije: Zanemaruje postavku Ne ometaj"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Napredno"</string>
    <string name="configure_apps" msgid="5468359087126598115">"Konfiguriraj aplikacije"</string>
    <string name="unknown_app" msgid="2027248925719898714">"Nepoznata aplikacija"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Upravitelj odobrenja"</string>
    <string name="app_permissions_summary" msgid="2709819220672938860">"Aplikacije koje koriste: <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="app_permissions_summary_more" msgid="6247952473615352350">"Aplikacije koje koriste odobrenja: <xliff:g id="APPS">%1$s</xliff:g> i drugo"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Dodirnite za buđenje"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dva puta dodirnite bilo gdje na zaslonu da probudite uređaj"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Otvaranje linkova"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ne otvaraj podržane linkove"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Otvori <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Otvori <xliff:g id="DOMAIN">%s</xliff:g> i druge URL-ove"</string>
    <string name="domain_urls_apps_summary_off" msgid="2534980824850890416">"Nema aplikacija koje mogu otvoriti podržane linkove"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="7864816862441985323">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija koja otvara podržane linkove</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije koje otvaraju podržane linkove</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija koje otvaraju podržane linkove</item>
    </plurals>
    <string name="app_link_open_always" msgid="9167065494930657503">"Dozvoli aplikaciji da otvara podržane linkove"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Pitaj svaki put"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Nemoj dozvoliti aplikaciji da otvara linkove"</string>
    <plurals name="app_link_open_always_summary" formatted="false" msgid="1816161439007251694">
      <item quantity="one">Aplikacija polaže pravo da obrađuje <xliff:g id="COUNT_1">%d</xliff:g> link</item>
      <item quantity="few">Aplikacija polaže pravo da obrađuje <xliff:g id="COUNT_1">%d</xliff:g> linka</item>
      <item quantity="other">Aplikacija polaže pravo da obrađuje <xliff:g id="COUNT_1">%d</xliff:g> linkova</item>
    </plurals>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikacija polaže pravo da obrađuje sljedeće linkove:"</string>
    <string name="default_apps_title" msgid="6943471331817718664">"Zadano"</string>
    <string name="default_for_work" msgid="537558180548617528">"Uobičajeno za rad"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Pomoć i glasovni unos"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Aplikac. digitalnog asistenta"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Zadana apl. digital. asistenta"</string>
    <string name="assistant_security_warning_title" msgid="6444187332360938730">"Želite li da <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> bude vaš asistent?"</string>
    <string name="assistant_security_warning" msgid="5623237187748811070">"Asistent dobija mogućnost čitanja informacija o aplikacijama koje se koriste na vašem sistemu, uključujući informacije vidljive na ekranu ili dostupne unutar aplikacija."</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Pristajem"</string>
    <string name="assistant_security_warning_disagree" msgid="1539182108068356410">"Ne slažem se"</string>
    <string name="choose_voice_input_title" msgid="4855506199101586943">"Odaberite glasovni unos"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Aplikacija preglednika"</string>
    <string name="default_browser_title_none" msgid="4691907418284764833">"Nema zadanog pretraživača"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikacija za telefon"</string>
    <string name="default_app" msgid="445053777504688596">"(zadano)"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistem)"</string>
    <string name="system_default_app" msgid="2647834628622214931">"(Sistemski zadano)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Pohrana aplikacija"</string>
    <string name="usage_access" msgid="5487993885373893282">"Pristup korištenju"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Dopusti pristup korištenju"</string>
    <string name="app_usage_preference" msgid="7062447555623339120">"Postavke upotrebe aplikacija"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Vrijeme korištenja uređaja"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Pristup korištenju omogućava praćenje drugih aplikacija koje koristite i učestalosti korištenja, kao i praćenje vašeg operatera, postavke jezika i drugo."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memorija"</string>
    <string name="memory_details_title" msgid="3048107441540417799">"Detalji o memoriji"</string>
    <string name="always_running" msgid="9012705720688200252">"Uvijek je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Ponekad je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Rijetko u funkciji (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="8721866158069974846">"Maksimalno"</string>
    <string name="memory_avg_use" msgid="4620476409349875703">"U prosjeku"</string>
    <string name="memory_max_desc" msgid="6966923521720393526">"Maksimalno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="2632995851138152303">"<xliff:g id="MEMORY">%1$s</xliff:g> u proseku"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="4239069158701023623">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimizacija baterije"</string>
    <string name="additional_battery_info" msgid="3104208543623068714">"Obavještenja o upotrebi"</string>
    <string name="show_all_apps" msgid="4490719452453223082">"Prikaži korištenje cijelog uređaja"</string>
    <string name="hide_extra_apps" msgid="7313907836289865123">"Prikaži korištenje aplikacije"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="573433136005336970">
      <item quantity="one"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija se ne ponaša kako treba</item>
      <item quantity="few"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacije se ne ponašaju kako treba</item>
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija se ne ponaša kako treba</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="8013115866788425817">
      <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="447849271630431531">"Bez optimizacije"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Nije optimizirano"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizacija potrošnje baterije"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimizacija baterije je nedostupna"</string>
    <string name="high_power_desc" msgid="2753076899835765338">"Ne primjenjuje se optimizacija baterije. Tako se baterija može brže isprazniti."</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Dopustiti aplikaciji da uvijek radi u pozadini?"</string>
    <string name="high_power_prompt_body" msgid="6460557929559616041">"Ako aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> dozvolite da uvijek radi u pozadini, može se skratiti vijek trajanja baterije. \n\nTo možete promijeniti kasnije ako odete u Postavke &gt; Aplikacije i obavještenja."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> iskorištenosti od posljednje potpune napunjenosti"</string>
    <string name="battery_power_management" msgid="7507188088567087384">"Upravljanje napajanjem"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Nema potrošnje baterije od prošlog potpunog punjenja"</string>
    <string name="app_notification_preferences" msgid="2004680717999108725">"Postavke aplikacije"</string>
    <string name="system_ui_settings" msgid="936169564323330967">"Prikaži podešivač za SystemUI"</string>
    <string name="additional_permissions" msgid="4656871347558988462">"Dodatna odobrenja"</string>
    <string name="additional_permissions_more" msgid="8188145515437525307">"Još <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Podijeliti izvještaj o grešci?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Vaš IT administrator je zatražio izvještaj o grešci kako bi pomogao u rješavanju problema ovog uređaja. Može doći do dijeljenja aplikacija i podataka."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Vaš IT administrator je zatražio izvještaj o grešci kako bi pomogao u rješavanju problema na ovom uređaju. To može uzrokovati dijeljenje aplikacija i podataka te privremeno usporiti vaš uređaj."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Ovaj izvještaj o grešci se dijeli sa vašim IT administratorom. Kontaktirajte ga da dobijete više informacija."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Podijelite"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Odbij"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Nema prijenosa podataka"</string>
    <string name="usb_use_charging_only_desc" msgid="1234421230461847336">"Samo puni ovaj uređaj"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Punjenje povezanog uređaja"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Prijenos fajlova"</string>
    <string name="usb_use_file_transfers_desc" msgid="1020257823387107336">"Prebacite fajlove na drugi uređaj"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="7490250033610745765">"Prebacuje slike ili fajlove ukoliko MTP nije podržan (PTP)"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Povezivanje mobitela putem USB-a"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="6464135515868405143">"Koristite uređaj u MIDI načinu"</string>
    <string name="usb_use" msgid="6783183432648438528">"Koristite USB za"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Zadana USB konfiguracija"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Kada se poveže drugi uređaj i vaš telefon je otključan, primijenit će se ove postavke. Povežite se samo s pouzdanim uređajima."</string>
    <!-- no translation found for usb_power_title (5602112548385798646) -->
    <skip />
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Postavke USB-a"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB-om upravlja"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Povezani uređaj"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Ovaj uređaj"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Prebacivanje…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Prebacivanje nije uspjelo"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Punjenje ovog uređaja"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Punjenje povezanog uređaja"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Prijenos fajlova"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Povezivanje mobitela putem USB-a"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Prijenos fajlova i napajanje"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Povezivanje mobitela putem USB-a i napajanje"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP i napajanje"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI i napajanje"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Provjera u pozadini"</string>
    <string name="background_check_title" msgid="225170874283229686">"Pun pristup pozadini"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Korištenje teksta s ekrana"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Omogućava aplikaciji za pomoć da pristupa sadržaju na ekranu kao tekstu"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Korištenje snimke ekrana"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Omogućava aplikaciji za pomoć da pristupa slici ekrana"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Bljeskanje ekrana"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Ivice ekrana bljeskaju kada aplikacija za pomoć pristupi tekstu s ekrana ili snimku ekrana"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Aplikacije za pomoć vam mogu pomoći na osnovu informacija s ekrana koji pregledate. Kako bi vam pružile sveukupnu pomoć, neke aplikacije podržavaju i usluge pokretača i glasovnog unosa."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Prosječna iskorištenost memorije"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimalna upotreba memorije"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Korištenje memorije"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Korištenje aplikacija"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalji"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> memorije korišteno u prosjeku u zadnja 3 sata"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Nikakva memorija se ne koristi u posljednja tri sata"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Poredaj po prosječnoj upotrebi"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Poredaj po maksimalnom korištenju"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Performanse"</string>
    <string name="total_memory" msgid="5244174393008910567">"Ukupno memorije"</string>
    <string name="average_used" msgid="690235917394070169">"Prosječna iskorištenost (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Slobodno"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memorija koju koriste aplikacije"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="1355637088533572208">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija je koristila memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije su koristile memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija je koristilo memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="7260225121706316639">"Frekvencija"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimalno korištenje"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Nema korištenja podataka"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Dozvoliti da <xliff:g id="APP">%1$s</xliff:g> pristupa načinu rada Ne ometaj?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikacija će biti u mogućnosti da uključi/isključi način rada Ne ometaj i da izmijeni povezane postavke."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Mora ostati uključeno jer je uključen pristup obavještenjima"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Opozvati pristup ka usluzi Ne ometaj za aplikaciju <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Sva pravila za uslugu Ne ometaj koje je kreirala ova aplikacija, biti će uklonjena."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ne optimiziraj"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizuj"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Baterija se može brže isprazniti. Aplikaciji više neće biti ograničena potrošnja baterije u pozadini."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Preporučuje se za duže trajanje baterije"</string>
    <string name="ignore_optimizations_title" msgid="3464172726254542889">"Želite da dozvolite aplikaciji <xliff:g id="APP">%s</xliff:g> da ignoriše optimizacije baterije?"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Nijedno"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Isključivanjem pristupa korištenju za ovu aplikaciju nećete spriječiti administratora da prati podatke o korištenju u aplikacija u vašem radnom profilu."</string>
    <string name="accessibility_lock_screen_progress" msgid="4597298121698665401">"Iskorištenih znakova: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_apps_title" msgid="1537949185175079866">"Aplikacije"</string>
    <string name="system_alert_window_access_title" msgid="3074573819155116817">"Prikaz preko drugih aplikacija"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Dozvoli prikaz preko drugih aplikacija"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Dozvolite ovoj aplikaciji da prekrije ostale aplikacije koje koristite. Ova aplikacija će moći vidjeti gdje dodirujete ili promijeniti ono što je prikazano na ekranu."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Pristup svim fajlovima"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Dozvoli pristup za upravljanje svim fajlovima"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Dozvolite ovoj aplikaciji da čita, mijenja i briše sve fajlove na ovom uređaju ili svim povezanim uređajima za pohranu. Ako to dozvolite, aplikacija može pristupati fajlovima bez vašeg znanja."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Može da pristupa svim fajlovima"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr slušalac virtuelne realnosti stereo pomoćna usluga"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_summary" msgid="1435856750594492891">"Aplikacije s odobrenjem za prikaz preko drugih aplikacija: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikacije s odobrenjem"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Dozvoljeno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nije dozvoljeno"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instaliranje aplikacije nepoznati izvori"</string>
    <string name="write_settings" msgid="6864794401614425894">"Izmjena postavki sistema"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"pisati izmijeniti sistemske postavke"</string>
    <string name="write_settings_summary" msgid="2085800775513476479">"Aplikacije sa odobrenjem za mijenjanje postavki sistema: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Mogu instalirati druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Mogu mijenjati postavke sistema"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Mogu mijenjati postavke sistema"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Izmjeni postavke sistema"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Dozvoli izmjenu postavki sistema"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Ovo odobrenje omogućava aplikaciji da izmijeni postavke sistema."</string>
    <string name="write_settings_on" msgid="8533286548451191112">"Da"</string>
    <string name="write_settings_off" msgid="1781103034490679144">"Ne"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Dozvoli iz ovog izvora"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Dvostruko uvrtanje za otvaranje kamere"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Da biste otvorili aplikaciju za kameru, dva puta uvrnite zglob"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="8264757967127716261">"Dva pritiska na napajanje za kameru"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="1539147023700755155">"Brzo otvaranje fotoaparata bez otključavanja ekrana"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Veličina prikaza"</string>
    <string name="screen_zoom_short_summary" msgid="2458636490408833800">"Povećajte ili smanjite stavke na ekranu"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"gustoća prikaza, uvećanje ekrana, promijeni veličinu, mijenjanje veličine"</string>
    <string name="screen_zoom_summary" msgid="1362984939045594989">"Smanjite ili povećajte stavke na ekranu. Neke aplikacije s vašeg ekrana mogu promijeniti svoj položaj."</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Pregled"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Smanji"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Povećaj"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="2896036059049355968">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="4873109337506890558">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="2641317981482545659">"Zdravo, Adi!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6528272610590915790">"Hej, želiš li da danas popijemo kafu i ispričamo se?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="6930848361702066106">"Može, super. Znam jedno dobro mjesto u blizini."</string>
    <string name="screen_zoom_conversation_message_4" msgid="2501043894465807210">"Savršeno!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="512353741016062507">"Uto 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="472183807915497199">"Uto 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="1659313906250856104">"Uto 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2046797647382623313">"Uto 18:03"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nije povezano"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nije povezano"</string>
    <string name="data_usage_summary_format" msgid="6844301859713164522">"Iskorišteno <xliff:g id="AMOUNT">%1$s</xliff:g> podataka"</string>
    <string name="data_usage_wifi_format" msgid="7644390582649568117">"<xliff:g id="AMOUNT">^1</xliff:g> iskorišteno na WiFi mreži"</string>
    <plurals name="notification_summary" formatted="false" msgid="7638388920823212470">
      <item quantity="one">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikaciju</item>
      <item quantity="few">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikacije</item>
      <item quantity="other">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="notification_summary_none" msgid="9179312319023988089">"Uključeno za sve aplikacije"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Broj instaliranih aplikacija: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="apps_summary_example" msgid="6034002063446955592">"Instalirane su 24 aplikacije"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Iskorišteno <xliff:g id="PERCENTAGE">%1$s</xliff:g> - Slobodno <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="storage_summary_with_sdcard" msgid="2063780050580228868">"Unutrašnja pohrana: iskorišteno <xliff:g id="PERCENTAGE">%1$s</xliff:g> - slobodno <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_summary" msgid="5526061030874717172">"Stanje mirovanja nakon <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="display_dashboard_summary" msgid="5102247404958535634">"Pozadinska slika, mirovanje, veličina fonta"</string>
    <string name="display_dashboard_summary_with_style" msgid="2792175367835485163">"Stilovi, pozadinske slike, istek vremena ekrana, veličina fonta"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="6198590533661927162">"Stanje mirovanja, veličina slova"</string>
    <string name="display_summary_example" msgid="4275121979039344438">"Pokreni stanje mirovanja nakon 10 minuta neaktivnosti"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Iskorišteno prosječno <xliff:g id="USED_MEMORY">%1$s</xliff:g> od ukupno <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prijavljeni ste kao <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="5513009140568552693">"<xliff:g id="APP_NAME">%1$s</xliff:g> je zadana aplikacija"</string>
    <string name="backup_disabled" msgid="4503062265560959320">"Izrada sigurnosnih kopija je onemogućena"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Ažurirano na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Dostupno je ažuriranje"</string>
    <string name="disabled_by_policy_title" msgid="8296938784202750494">"Radnja nije dozvoljena"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Nije moguće promijeniti jačinu zvuka"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="2776004460663768982">"Pozivanje nije dozvoljeno"</string>
    <string name="disabled_by_policy_title_sms" msgid="6309460145439706922">"SMS poruka nije dozvoljena"</string>
    <string name="disabled_by_policy_title_camera" msgid="8567781468959299078">"Kamera nije dozvoljena"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6137746705692573992">"Snimak ekrana nije dozvoljen"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Nije moguće otvoriti aplikaciju"</string>
    <string name="default_admin_support_msg" msgid="8338570262037182531">"Ako imate pitanja, obratite se IT administratoru"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Više detalja"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Vaš administrator može pratiti i upravljati aplikacijama i podacima povezanim s vašim radnim profilom, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Vaš administrator može pratiti i upravljati aplikacijama i podacima koji su povezani s ovim korisnikom, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Vaš administrator može pratiti i upravljati aplikacijama i podacima koji su povezani s ovim uređajem, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Isključi"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Uključi"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Prikaži"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Sakrij"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Pristupna tačka je aktivna"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Airplane način rada je uključen"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Mreže nisu dostupne"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Uključen način rada Ne ometaj"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Zvuk na telefonu je isključen"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"S izuzecima"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Ušteda baterije je uključena"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funkcije su ograničene"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Prijenos podataka na mobilnoj mreži je isključen"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet je dostupan samo putem WiFi mreže"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Ušteda podataka"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funkcije su ograničene"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Radni profil je isključen"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Za aplikacije i obavještenja"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Uključi zvuk"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Zvuk zvona je isključen"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Za pozive i obavještenja"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Samo vibracija"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Za pozive i obavještenja"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Postavite plan za Noćno svjetlo"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Automatski oboji ekran svaku noć"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Noćno svjetlo je uključeno"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Ekran ima žutu nijansu"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Nijanse sive"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Prikaži samo u sivoj boji"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Suzi"</string>
    <string name="suggestions_title_v2" msgid="421003737901460147">"Prijedlozi za vas"</string>
    <string name="suggestions_title" msgid="61841299295602686">"Prijedlozi"</string>
    <string name="suggestions_summary" msgid="1709710458908440469">"još <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="240124526378997009">"Još <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="5023679825210836444">
      <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="3789011332018516832">
      <item quantity="one">još <xliff:g id="COUNT">%1$d</xliff:g> prijedlog</item>
      <item quantity="few">još <xliff:g id="COUNT">%1$d</xliff:g> prijedloga</item>
      <item quantity="other">još <xliff:g id="COUNT">%1$d</xliff:g> prijedloga</item>
    </plurals>
    <string name="suggestion_remove" msgid="6753986344585367776">"Ukloni"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Hladna temperatura boje"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Koristite hladnije boje prikaza"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Isključite ekran kako biste primijenili promjenu boje"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Laserski senzor kamere"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatska ažuriranja sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Ažuriranje nakon što se uređaj ponovo pokrene"</string>
    <string name="usage" msgid="287782903846013936">"Potrošnja"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Prijenos podataka u aplikaciji"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Prijenos podataka putem WiFi-ja"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Prijenos podataka mimo mobilnog operatera"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Prijenos podataka putem Etherneta"</string>
    <string name="wifi" msgid="2932584495223243842">"WiFi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> putem prijenosa podataka"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> WiFi podataka"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> ethernet podataka"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Upozorenje o prijenosu pod. i ograničenje"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciklus prijenosa podataka na mob. mreži"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Upozorenje o prijenosu podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Ograničenje prijenosa podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Upozorenje o prijenosu podataka: <xliff:g id="ID_1">^1</xliff:g> / Ograničenje prijenosa podataka: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="6346655500491631357">"Mjesečno, na dan: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="network_restrictions" msgid="8385824604048229846">"Mrežna ograničenja"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="3875128958788008975">
      <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="5672761970087591211">"Obračun podataka koji vrši operater se može razlikovati od obračuna koji vrši uređaj."</string>
    <string name="non_carrier_data_usage_warning" msgid="7361998122602474430">"Ne obuhvata podatke koje koriste mreže mobilnog operatera"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Iskorišteno je <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Postavi upozor. o prij. podat."</string>
    <string name="data_warning" msgid="2925054658166062884">"Upozorenje o prijenosu podataka"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Uređaj mjeri upozorenje o prijenosu podataka i ograničenje prijenosa podataka. Ovo se može razlikovati od prijenosa podataka kojeg je izmjerio mobilni operater."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Postavi ogranič. prij. podat."</string>
    <string name="data_limit" msgid="8731731657513652363">"Ograničenje prijenosa podataka"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<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="1499586749829665889">"Konfiguracija"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Ostale aplikacije uključene u korištenje"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="3316296488378947221">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija smije upotrebljavati neograničen prijenos podataka kada je uključena Ušteda podataka</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije smiju upotrebljavati neograničen prijenos podataka kada je uključena Ušteda podataka</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija smije upotrebljavati neograničen prijenos podataka kada je uključena Ušteda podataka</item>
    </plurals>
    <string name="data_usage_title" msgid="4039024073687469094">"Primarni plan prijenosa podataka"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Wi‑Fi podaci"</string>
    <string name="data_used" msgid="7770571947591789895">"Iskorišteno je <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Iskorišteno je <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Prekoračenje: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Još <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafikon koji prikazuje potrošnju prijenosa podataka od <xliff:g id="START_DATE">%1$s</xliff:g> do <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Nema potrošnje prijenosa podataka u ovom rasponu datuma"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="661792524671718753">
      <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="1694844019159277504">"Nema preostalog vremena"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Preostalo je manje od 1 dana"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Ažurirao mob. operater <xliff:g id="ID_1">^1</xliff:g> prije <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Ažurirano prije <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Upravo ažurirao mob. operater <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Upravo ažurirano"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Pogledaj plan"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Prikaži detalje"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Ušteda podataka"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neograničen prijenos podataka"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Pozadinski podaci su isključeni"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Uključeno"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Isključeno"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Koristi funkciju Ušteda podataka"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neograničen prijenos podataka"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Dozvolite neograničen pristup podacima kada je uključena Ušteda podataka"</string>
    <string name="home_app" msgid="6056850504746902747">"Aplikacija na početnom ekranu"</string>
    <string name="no_default_home" msgid="3588073707316139318">"Nema zadane početne aplikacije"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="4098653943835666086">"Sigurno pokretanje"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="311325321794497404">"Zahtijeva uzorak za pokretanje vašeg uređaja. Dok je isključen, ovaj uređaj ne može primati pozive, poruke, obavijesti ili alarme."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="1881271630312222251">"Zahtijeva PIN za pokretanje vašeg uređaja. Dok je isključen, ovaj uređaj ne može primati pozive, poruke, obavijesti ili alarme."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="8651761245246411947">"Zahtijeva lozinku za pokretanje vašeg uređaja. Dok je isključen, ovaj uređaj ne može primati pozive, poruke, obavijesti ili alarme."</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Dodajte još jedan otisak prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Otključajte nekim drugim prstom"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Uključeno"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Uključit će se na <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Isključeno"</string>
    <string name="battery_saver_button_turn_on" msgid="2206239048232352476">"Uključi sada"</string>
    <string name="battery_saver_button_turn_off" msgid="6371072408072481484">"Isključi sada"</string>
    <string name="not_battery_optimizing" msgid="8361294470943376258">"Aplikacija ne koristiti optimizaciju baterije"</string>
    <string name="lockscreen_remote_input" msgid="6030274311185811503">"Ako je uređaj zaključan, spriječiti kucanje odgovora ili drugog teksta u obavijestima"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Zadana provjera pravopisa"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Odaberite provjeru pravopisa"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Koristi provjeru pravopisa"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nije odabrano"</string>
    <string name="notification_log_no_title" msgid="2343315128609978203">"(ništa)"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"ključ"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupa"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(sažetak)"</string>
    <string name="notification_log_details_visibility" msgid="6811292866832243357">"vidljivost"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"javnaVerzija"</string>
    <string name="notification_log_details_priority" msgid="4772047133062255513">"prioritet"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"važnost"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"objašnjenje"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"može prikazati značku"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"namjera"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"izbrisati namjeru"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"namjera za cijeli ekran"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"akcije"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"naslov"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"daljinski unosi"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"prilagođeni prikaz"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"dodaci"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"veličina paketa"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"izdato obavještenje"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_none" msgid="1090852853755089991">"ništa"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Rangirani objekt nedostaje."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Rangirani objekt ne sadrži ovu tipku."</string>
    <string name="theme_customization_device_default" msgid="7641813022590999286">"Zadana postavka uređaja"</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Urez u ekranu"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"urez ekrana, urez"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Zadana postavka uređaja"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Primjena preklapanja nije uspjela"</string>
    <string name="special_access" msgid="1767980727423395147">"Poseban pristup aplikacija"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija može koristiti neograničen prijenos podataka</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije mogu koristiti neograničen prijenos podataka</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija može koristiti neograničen prijenos podataka</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Prikaži više"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="3783325656948378111">"Zaista želite izbrisati korisničke podatke i pretvoriti u šifrirani fajl?"</string>
    <string name="button_confirm_convert_fbe" msgid="339648921918438106">"Obriši i pretvori"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Poništi ograničenje brzine ShortcutManagera"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Ograničenje brzine ShortcutManagera je poništeno"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrolirajte informacije na zaključanom ekranu"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Pokaži ili sakrij sadržaj obavještenja"</string>
    <string name="page_tab_title_summary" msgid="7188875610123234454">"Sve"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Savjeti i podrška"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Najmanja širina"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nijedna instalirana aplikacija nije zatražila pristup premijum SMS-ovima"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Usluga Premium SMS se možda dodatno plaća te će trošak biti na računu koji dobijate od operatera. Ukoliko aplikaciji date odobrenje, moći ćete slati premium SMS poruke putem te aplikacije."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Pristup premijum SMS-ovima"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Isključeno"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Povezano s mrežom <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Povezan s više uređaja"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Način rada za demonstraciju Sistemskog UI-a"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tamna tema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Privremeno onemogućeno zbog Uštede baterije"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Privremeno uključeno zbog Uštede baterije"</string>
    <string name="dark_ui_settings_dark_summary" msgid="1214821092462388494">"Podržane aplikacije će se također prebaciti na tamnu temu"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="250437497729953965">"Razumijem"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Isprobajte Tamnu temu"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pomaže da se produži vijek trajanja baterije"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Pločice programera za brze postavke"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Onemogući istek vremena za adb ovlaštenje"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Onemogućava se automatsko ukidanje adb ovlaštenja za sisteme koji se nisu ponovo povezali u zadanom roku (7 dana) ili u roku koji je konfigurirao korisnik (minimalno 1 dan)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Winscope praćenje"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Senzori su isključeni"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Postavke radnog profila"</string>
    <string name="managed_profile_contact_search_title" msgid="7685402733942182110">"Pretraživanje kontakata"</string>
    <string name="managed_profile_contact_search_summary" msgid="2771343453017731940">"Dozvolite svojoj organizaciji da pretražuje kontakte kako bi identificirala pozivaoce i kontakte"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendar za više profila"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Prikaz poslovnih događaja u ličnom kalendaru"</string>
    <plurals name="hours" formatted="false" msgid="1853396353451635458">
      <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="6244503272924425418">
      <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="4237020272336995370">
      <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="519158151463974656">"Upravljanje prostorom za pohranu"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Radi lakšeg oslobađanja prostora za pohranu, upravitelj pohranom s vašeg uređaja uklanja sigurnosne kopije fotografija i videozapisa."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Ukloni fotografije i videozapise"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Upravitelj prostora za pohranu"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Koristi Upravitelja pohrane"</string>
    <string name="deletion_helper_automatic_title" msgid="597196990024769472">"Automatski"</string>
    <string name="deletion_helper_manual_title" msgid="1068812971600327101">"Ručno"</string>
    <string name="deletion_helper_preference_title" msgid="6364023246849161274">"Oslobodite prostor odmah"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Pokreti"</string>
    <string name="gesture_preference_summary" product="default" msgid="7941981260703379398">"Brzi pokreti za kontrolu nad telefonom"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4031666250963488007">"Brzi pokreti za kontrolu nad tableta"</string>
    <string name="gesture_preference_summary" product="device" msgid="3520072325356373349">"Brzi pokreti za kontrolu uređaja"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Brzo otvaranje kamere"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Da brzo otvorite kameru, dvaput pritisnite dugme za uključivanje. Funkcionira na svim ekranima."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="4299496243418753571">"Brzo otvorite kameru"</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Obrtanje kamere za selfi"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="8178844037382604158">"Snimajte selfije brže"</string>
    <string name="system_navigation_title" msgid="1698862900901417194">"Navigacija sistemom"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigacija pomoću 2 dugmeta"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Da prebacite aplikacije, na dugmetu za početni ekran prevucite prema gore. Za prikaz svih aplikacija, ponovo prevucite prema gore. Dodirnite dugme za povratak da se vratite."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="5754081720589900007">"Isprobajte novo dugme za Početni ekran"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="8885866570559435110">"Uključite novi pokret za promjenu aplikacije"</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Sigurnost i hitni poziv"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigacija pokretima"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Za odlazak na početni ekran, prevucite prema gore s dna ekrana. Da prebacite aplikacije, prevucite prema gore s dna, zadržite, a zatim otpustite. Za vraćanje, prevucite s lijevog ili desnog ruba ekrana."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigacija pomoću 3 dugmeta"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Za vraćanje, otvaranje početnog ekrana i promjenu aplikacije, koristite dugmad u dnu ekrana."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigiranje za sistem, navigiranje pomoću 2 dugmeta, navigiranje pomoću 3 dugmeta, navigiranje pokretima, prevlačenje"</string>
    <string name="gesture_not_supported_dialog_message" msgid="5316512246119347889">"Nije podržano u vašoj zadanoj aplikaciji početnog ekrana, <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g>"</string>
    <string name="gesture_not_supported_positive_button" msgid="7909969459977021893">"Promijeni zadanu aplik. početnog ekrana"</string>
    <string name="information_label" msgid="6939310810756569298">"Informacije"</string>
    <string name="low_label" msgid="6525629096999711220">"Nisko"</string>
    <string name="high_label" msgid="357503396626018487">"Visoko"</string>
    <string name="left_edge" msgid="1513576842959071849">"Lijeva ivica"</string>
    <string name="right_edge" msgid="1505309103265829121">"Desna ivica"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Veća osjetljivost može izazvati probleme prilikom korištenja pokreta aplikacija uz ivice ekrana."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Osjetljivost pokreta za povratak"</string>
    <string name="gesture_settings_activity_title" msgid="6047431928567911330">"Postavke pokreta"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigiranje pokretima, osjetljivost pokreta za povratak, pokret za povratak"</string>
    <string name="ambient_display_title" product="default" msgid="5885136049497127396">"Dodirnite dvaput da provjerite telefon"</string>
    <string name="ambient_display_title" product="tablet" msgid="205744440641466921">"Provjera tableta dvostrukim dodirom"</string>
    <string name="ambient_display_title" product="device" msgid="4164103424628824786">"Provjera uređaja dvostrukim dodirom"</string>
    <string name="swipe_bottom_to_notifications_title" msgid="7631744948948666524">"Prevucite za obavještenja"</string>
    <string name="swipe_bottom_to_notifications_summary" msgid="8073261995155440308">"Prevucite prema dolje na dnu ekrana da prikažete obavještenja"</string>
    <string name="one_handed_title" msgid="1741600445540072513">"Način rada jednom rukom"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Koristi način rada jednom rukom"</string>
    <string name="one_handed_app_taps_to_exit" msgid="1496702498286387879">"Izađi pri prebacivanju između aplikacija"</string>
    <string name="one_handed_timeout_title" msgid="8851767822595789976">"Isteklo vrijeme"</string>
    <string name="one_handed_timeout_short" msgid="304069319841702995">"4 sekunde"</string>
    <string name="one_handed_timeout_medium" msgid="6723411319911799018">"8 sekundi"</string>
    <string name="one_handed_timeout_long" msgid="6537332654662635890">"12 sekundi"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"mogućnost dosega"</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Dvaput dodirnite ekran da provjerite vrijeme, obavještenja i druge informacije."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="4418310591912877548">"Podignite da provjerite telefon"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="8055486872070888377">"Podignite za provjeru tableta"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="8980156994848721455">"Podignite za provjeru uređaja"</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Aktiviranje ekrana"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="1087355013674109242">"Podignite telefon da provjerite vrijeme, obavještenja i druge informacije."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="2589556997034530529">"Da provjerite vrijeme, obavještenja i druge informacije, podignite tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="1916011370011115627">"Da provjerite vrijeme, obavještenja i druge informacije, podignite uređaj."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="2811332293938467179">"Dodirnite da provjerite telefon"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="6461531447715370632">"Dodirnite da provjerite tablet"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="4423803387551153840">"Dodirnite da provjerite uređaj"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Da provjerite vrijeme, obavještenja i druge informacije, dodirnite ekran."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Pomoć u hitnim slučajevima"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7494629420708117232">"Koristite pomoć u hitnim slučajevima"</string>
    <string name="emergency_gesture_entrypoint_summary" msgid="4730874229911208834">"Funkcijom upravlja <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="emergency_gesture_screen_summary" msgid="458991229689082120">"Pokrenite radnje ispod brzim pritiskanjem dugmeta za uključivanje 5 ili više puta"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Reproduciraj alarm s odbrojavanjem"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="9215504009890604179">"Reproduciranje glasnog zvuka prije slanja obavještenja za pomoć"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Poziv za pomoć"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Broj za pomoć"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Dodirnite da promijenite"</string>
    <string name="emergency_gesture_number_override_notes" msgid="7270300987756837957">"Ako unesete broj koji nije za hitne slučajeve:\n • Vaš uređaj mora biti otključan kako biste koristili pomoć u hitnim slučajevima\n • Možda nećete dobiti odgovor na poziv"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Prevucite prstom za obavještenja"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Prevlačenje prstom"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="286662791588779673">"Da provjerite obavještenja, prevucite prstom prema dolje po senzoru za otisak prsta na poleđini uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="8642092907817554454">"Da provjerite obavještenja, prevucite prstom prema dolje po senzoru za otisak prsta na poleđini uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="3888927017311372398">"Da provjerite obavještenja, prevucite prstom prema dolje po senzoru za otisak prsta na poleđini uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Brzo pregledajte obavještenja"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Uključeno"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Isključeno"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Program za učitavanje operativnog sistema je već otključan"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="8045017109714463041">"Prvo se povežite na internet"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Povežite se na internet ili kontaktirajte svog operatera"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nedostupno na uređajima koje je zaključao operater"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Ponovo pokrenite uređaj da omogućite funkciju zaštite uređaja."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> je ukupno na raspolaganju\n\nPosljednji put je pokrenuto <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant aplikacije"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Otvaranje linkova u aplikacijama, čak iako nisu instalirane"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant aplikacije"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Postavke instant aplikacija"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Instalirane aplikacije"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Vašom pohranom sada upravlja upravitelj pohrane"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Računi korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="3126887329521705210">"Konfiguriraj"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automatski sinhroniziraj podatke aplikacija"</string>
    <string name="auto_sync_personal_account_title" msgid="3544275021920818595">"Automatsko sinhroniziranje ličnih podataka"</string>
    <string name="auto_sync_work_account_title" msgid="6060310415978781885">"Automatsko sinhroniziranje radnih podataka"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Dozvoli aplikacijama da automatski osvježavaju podatke"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sinhronizacija računa"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinhronizacija je uključena za <xliff:g id="ID_1">%1$d</xliff:g> od ukupnog broja stavki: <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinhronizacija je uključena za sve stavke"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinhronizacija je isključena za sve stavke"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Podaci o upravljanom uređaju"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Promjene i postavke kojima upravlja vaša organizacija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Promjene i postavke kojima upravlja organizacija <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Za davanje pristupa vašim radnim podacima, vaša organizacija može na vašem uređaju promijeniti postavke i instalirati softver.\n\nZa više informacija, obratite se administratoru vaše organizacije."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Vrste informacija koje vaša organizacija može vidjeti"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Izmjene koje je izvršio adminstrator vaše organizacije"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Vaš pristup ovom uređaju"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Podaci koji su povezani s vašim računom, kao što su e-pošta ili kalendar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lista aplikacija na vašem uređaju"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Utrošeno vrijeme i podaci za svaku aplikaciju"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Najskoriji zapis mrežnog saobraćaja"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Najnoviji izvještaj o greškama"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Najnoviji zapisnik o aktivnostima"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Nema"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Aplikacije su instalirane"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Broj aplikacija je samo procjena. Možda nisu obuhvaćene aplikacije koje su instalirane izvan Play trgovine."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="5403847001419529018">
      <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="8023838718108456971">"Odobrenja za lokacije"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Odobrenja za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Odobrenja za kameru"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Zadane aplikacije"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="8568544906431825430">
      <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="3278314982700662246">"Zadana tastatura"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Postavljeno kao <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Uključen je uvijek aktivni VPN"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Uvijek aktivni VPN je uključen u vašem ličnom profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Uvijek aktivni VPN je uključen u vašem radnom profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Globalno postavljanje za HTTP proksi"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Pouzdani akreditivi"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Pouzdani akreditivi na vašem ličnom profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Pouzdani akreditivi na vašem radnom profilu"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="6459725295322004179">
      <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="464054894363899866">"Administrator može zaključati uređaj i postaviti novu lozinku"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administrator može izbrisati sve podatke iz uređaja"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Neuspjeli pokušaji upisivanja lozinke prije brisanja svih podataka na uređaju"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Neuspjeli pokušaji upisivanja lozinke prije brisanja svih podataka radnog profila"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="8811973918944217791">
      <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="3067459392402324538">"Ovim uređajem upravlja vaša organizacija."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Ovim uređajem upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Saznajte više"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="8112432929729136399">
      <item quantity="one">Aplikacija za kameru</item>
      <item quantity="few">Aplikacije za kameru</item>
      <item quantity="other">Aplikacija za kameru</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikacija za kalendar"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikacija za kontakte"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="8338194872609410234">
      <item quantity="one">Aplikacija klijenta za e-poštu</item>
      <item quantity="few">Aplikacije klijenta za e-poštu</item>
      <item quantity="other">Aplikacija klijenta za e-poštu</item>
    </plurals>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikacija za mape"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="4222188821845826493">
      <item quantity="one">Aplikacija za telefon</item>
      <item quantity="few">Aplikacije za telefon</item>
      <item quantity="other">Aplikacija za telefon</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<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="7019703249717854148">"<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="6926197783745481869">"Fotografije i videozapisi"</string>
    <string name="storage_music_audio" msgid="1185624135490182822">"Muzika i zvuk"</string>
    <string name="storage_games" msgid="1176568610086802469">"Igre"</string>
    <string name="storage_other_apps" msgid="5902520888043081176">"Druge aplikacije"</string>
    <string name="storage_files" msgid="7968460921272772299">"Fajlovi"</string>
    <string name="storage_size_large_alternate" msgid="7555149858858591495">"<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="7102720999351050601">"Iskorišteno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="7211888326013020857">"iskor."</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Obriši aplikaciju"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Želite li ukloniti ovu instant aplikaciju?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Otvori"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Igre"</string>
    <string name="audio_files_title" msgid="5981409295669041303">"Audio fajlovi"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Iskorišteni prostor"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(deinstalirano za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(onemogućeno za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Usluga automatskog popunjavanja"</string>
    <string name="autofill_keywords" msgid="6260653325195017912">"automatski, popunjavanje, automatsko popunjavanje"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&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; koristi sadržaj na vašem ekranu da odredi šta se može automatski popuniti."</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatsko popunjavanje"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Nivo zapisivanja"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maksimalan broj zahtjeva po sesiji"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maksimalan broj vidljivih kompleta podataka"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Vraćanje na zadane vrijednosti"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Opcije za programere za automatsko popunjavanje su vraćene na zadane postavke"</string>
    <string name="location_category" msgid="3496759112306219062">"Lokacija"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Pokazatelj lokacije na statusnoj traci"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Prikaz za sve lokacije, uključujući mreže i povezivost"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Prisilno omogući potpuno GNSS mjerenje"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Praćenje svih konstelacija i frekvencija GNSS-a bez ciklusa rada"</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema uređaja"</string>
    <string name="default_theme" msgid="4815428567082263639">"Zadano"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Naziv mreže"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Prikaz naziva mreže na statusnoj traci"</string>
    <string name="storage_manager_indicator" msgid="6187509172735927297">"Upravitelj pohranom: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="2705959642617709265">"Isključeno"</string>
    <string name="storage_manager_indicator_on" msgid="8380330763647785309">"Uključeno"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant aplikacija"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Želite li isključiti upravitelja pohranom?"</string>
    <string name="storage_movies_tv" msgid="7897612625450668593">"Aplikacije za filmove i TV"</string>
    <string name="carrier_provisioning" msgid="7217868336140325816">"Operater koji pruža informacije"</string>
    <string name="trigger_carrier_provisioning" msgid="3288805742683538597">"Aktiviranje dodjele resursa operatera"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Ažurirajte način rada Ne ometaj"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pauzirajte obavještenja da ostanete fokusirani"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcija nije dostupna"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Ova funkcija je isključena jer usporava vaš telefon"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Uvijek prikaži dijaloški okvir za pad aplikacije"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Prikaz dijaloškog okvira pri svakom padu aplikacije"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Odaberite aplikaciju u kojoj je omogućen ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Aplikacija u kojoj je omogućen ANGLE nije postavljena"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikacija u kojoj je omogućen ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Postavke drajvera za grafiku"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Promjena postavki drajvera za grafiku"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kada je uključeno više drajvera za grafiku možete odabrati da za aplikacije koje su instalirane na uređaju koristite ažurirani drajver za grafiku."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Omogućeno za sve aplikacije"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Odabir drajvera za grafiku"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Zadano"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Drajver za igru"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Drajver programera"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Drajver za grafiku sistema"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Izmjene kompatibilnosti aplikacije"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Uključivanje/isključivanje izmjena kompatibilnosti aplikacije"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Zadano omogućene izmjene"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Zadano onemogućene izmjene"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Nema dostupnih apl."</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Promjene kompatibilnosti aplikacije je moguće izmijeniti isključivo kod aplikacija kod kojih je moguće izvršiti otklanjanje grešaka. Instalirajte aplikaciju kod koje je moguće izvršiti otklanjanje grešaka i pokušajte ponovo."</string>
    <string name="unsupported_setting_summary" product="default" msgid="1085229417771470172">"Postavka nije podržana na ovom telefonu"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="7402414129786489664">"Postavka nije podržana na ovom tabletu"</string>
    <string name="unsupported_setting_summary" product="device" msgid="3422953459122926833">"Postavka nije podržana na ovom uređaju"</string>
    <string name="disabled_for_user_setting_summary" msgid="9096036019081828639">"Trenutni korisnik ne može promijeniti postavku"</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Zavisi od druge postavke"</string>
    <string name="unknown_unavailability_setting_summary" msgid="9060213910510360231">"Postavka je nedostupna"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Račun"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Naziv uređaja"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Upravljanje WiFi mrežom"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"family link da upravlja WiFi mrežom"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Dozvolite ovoj aplikaciji da uključi ili isključi WiFi, skenira i konektuje se na WiFi, doda ili ukloni mreže, te pokrene lokalnu pristupnu tačku"</string>
    <string name="media_output_title" msgid="8283629315159510680">"Reprodukcija medija na"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Reproduciraj <xliff:g id="LABEL">%s</xliff:g> na"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Ovaj uređaj"</string>
    <string name="media_output_summary" product="default" msgid="4760338801715262899">"Telefon"</string>
    <string name="media_output_summary" product="tablet" msgid="5138101426462250247">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="3598300438694764381">"Uređaj"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Nedostupno za vrijeme poziva"</string>
    <string name="media_output_summary_unavailable" msgid="2695058965888813093">"Nedostupno"</string>
    <string name="media_output_group_panel_title" msgid="3086245179062913037">"Dodavanje izlaza"</string>
    <string name="media_output_group" msgid="7918231774595274396">"Grupa"</string>
    <string name="media_output_group_panel_single_device_summary" msgid="5027884071572180516">"1 odabrani uređaj"</string>
    <string name="media_output_group_panel_multiple_devices_summary" msgid="4838305763151455248">"Broj odabranih uređaja: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="media_output_switching" msgid="7488216595474868546">"Prebacivanje…"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Primanje poziva"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Ovaj APN se ne može promijeniti."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="1525940496459255289">"Poboljšanje trajanja baterije tableta"</string>
    <string name="battery_suggestion_title" product="device" msgid="2280773774080720377">"Poboljšanje trajanja baterije uređaja"</string>
    <string name="battery_suggestion_title" product="default" msgid="4811554469047272537">"Poboljšanje trajanja baterije telefona"</string>
    <string name="battery_suggestion_summary" msgid="8186720080540016197"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Sprečavanje zvonjenja"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Zajedno pritisnite dugme za napajanje i pojačavanje da postavite:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Prečica za sprečavanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibracija"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Isključen zvuk"</string>
    <string name="prevent_ringing_option_none" msgid="7776676007180834163">"Ne čini ništa"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibracija"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Isključi zvuk"</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detalji o mreži"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Aplikacije na vašem telefonu će moći vidjeti naziv vašeg uređaja. Također će ga moći vidjeti druge osobe prilikom povezivanja s Bluetooth uređajima i WiFi mrežom ili prilikom postavljanja WiFi pristupne tačke."</string>
    <string name="devices_title" msgid="649715719278562515">"Uređaji"</string>
    <string name="homepage_all_settings" msgid="1877827279189801035">"Sve postavke"</string>
    <string name="homepage_personal_settings" msgid="8312279476519359656">"Prijedlozi"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Odaberite mrežu"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Veza je prekinuta"</string>
    <string name="network_connected" msgid="7637745547242487795">"Povezano"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Povezivanje…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Povezivanje nije uspjelo"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nije pronađena nijedna mreža."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nisu pronađene mreže. Pokušajte ponovo."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(zabranjeno)"</string>
    <string name="no_sim_card" msgid="1497407489810953863">"Nema SIM kartice"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Nema SIM-a"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Nema"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Potreban je SIM da se povežete"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Potreban je SIM operatera <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> da se povežete"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Preferirani način rada mreže: preferiraj WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Preferirani način rada mreže: samo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Preferirani način rada mreže: samo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Preferirani način rada mreže: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Preferirani način rada mreže: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Preferirani način rada mreže: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Preferirani način rada mreže: samo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Preferirani način rada mreže: samo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Preferirani način rada mreže: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Preferirani način rada mreže: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Preferirani način rada mreže: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Preferirani način rada mreže: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Preferirani način rada mreže: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Preferirani način rada mreže: globalno"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Preferirani način rada mreže: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Preferirani način rada mreže: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Preferirani način rada mreže: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Preferirani način rada mreže: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Preferirani način rada mreže: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Preferirani način rada mreže: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Preferirani način rada mreže: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Preferirani način rada mreže: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Preferirani način rada mreže: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Preferirani način rada mreže: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Preferirani način rada mreže: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Preferirani način rada mreže: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Preferirani način rada mreže: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Preferirani način rada mreže: samo NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Preferirani način rada mreže: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Preferirani način rada mreže: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Preferirani način rada mreže: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Preferirani način rada mreže: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Preferirani način rada mreže: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Preferirani način rada mreže: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Preferirani način rada mreže: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Preferirani način rada mreže: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Preferirani način rada mreže: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Preferirani način rada mreže: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_recommended" msgid="4665525658003183348">" (preporučeno)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (preporučeno)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (preporučeno)"</string>
    <string name="label_available" msgid="5305726869955838606">"Dostupne mreže"</string>
    <string name="load_networks_progress" msgid="4717874401621250401">"Pretraživanje…"</string>
    <string name="register_on_network" msgid="2169662800750709709">"Registriranje na mrežu <xliff:g id="NETWORK">%s</xliff:g> je u toku…"</string>
    <string name="not_allowed" msgid="5756935665192962915">"Vaša SIM kartica ne dozvoljava povezivanje na ovu mrežu."</string>
    <string name="connect_later" msgid="2330538069949281352">"Trenutno se nije moguće povezati na ovu mrežu. Pokušajte ponovo kasnije."</string>
    <string name="registration_done" msgid="1750434215698850123">"Registrirano na mrežu."</string>
    <string name="select_automatically" msgid="2419752566747259155">"Automatski odaberi mrežu"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Postavke operatera"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Postavi prijenos podataka"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Pristup prijenosu podataka putem mobilne mreže"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon će se automatski prebaciti na ovog operatera kada bude u dometu"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="3309106501029928951">"Sim kartica nije dostupna"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Postavke za pozive"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Postavke za SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Pitaj svaki put"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Dodavanje mreže"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="5173633860800230925">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM-a</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM-ova</item>
    </plurals>
    <string name="default_for_calls" msgid="2788950217176988034">"Zadano za pozive"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Zadano za SMS-ove"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Zadano za pozive i SMS-ove"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Zadano za prijenos mobilnih podataka"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Prijenos mobilnih podataka je aktivan"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Prijenos mobilnih podataka je isključen"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Dostupno"</string>
    <string name="mobile_network_in_range" msgid="3528320750936028369">"U dometu"</string>
    <string name="mobile_network_not_in_range" msgid="5680896182395366584">"Nije u dometu"</string>
    <string name="mobile_network_list_add_more" msgid="4478586073355236604">"Dodaj još"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktivno/SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktivno/SIM"</string>
    <string name="mobile_network_active_esim" msgid="4673190244386572318">"Aktivno/preuzet SIM"</string>
    <string name="mobile_network_inactive_esim" msgid="2901035056727849007">"Neaktivno/preuzeti SIM-ovi"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Naziv i boja SIM-a"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Naziv"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Boja (koriste kompatibilne aplikacije)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Sačuvaj"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Koristite SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Isključeno"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Uklonite SIM karticu da onemogućite ovaj SIM"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Dodirnite da aktivirate operatera <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="2762744961192218789">"Prebaciti na operatera <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="8168680839542031781">"Aktivan može biti samo po jedan SIM.\n\nPrebacivanjem na operatera <xliff:g id="CARRIER1">%1$s</xliff:g> neće se otkazati usluga operatera <xliff:g id="CARRIER2">%2$s</xliff:g>."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8695772737522378095">"Prebaci na operatera <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Izbriši SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="6680959559589234726">"Nije moguće izbrisati SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6401922869095572710">"Nije moguće izbrisati ovaj SIM zbog greške.\n\nPonovo pokrenite uređaj i pokušajte ponovo."</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Preferirana vrsta mreže"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Promijenite način rada mreže"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Preferirana vrsta mreže"</string>
    <string name="carrier_settings_euicc" msgid="1541279297111378907">"Operater"</string>
    <string name="carrier_settings_version" msgid="4738147451583140935">"Verzija postavki"</string>
    <string name="call_category" msgid="641461844504128789">"Pozivanje"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Operater video pozivanja"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Odabir sistema"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Promijenite način rada CDMA rominga"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Odabir sistema"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Mreža"</string>
    <string name="network_select_title" msgid="4532395144000206685">"Mreža"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA pretplata"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Promjena između RUIM/SIM i NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"pretplata"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatska registracija…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Dozvoliti roming podataka?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Raspitajte se kod svog mobilnog operatera za cijene."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Prijenos podataka u aplikaciji"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Mrežni način <xliff:g id="NETWORKMODEID">%1$d</xliff:g> nije važeći. Zanemarite."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Nazivi pristupne tačke"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nedostupno kada ste povezani s operaterom <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Pogledajte više"</string>
    <string name="see_less" msgid="2642392725363552793">"Prikaži manje"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Uključiti operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Uključiti SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Prebaciti na mobilnog operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Prebaciti se na korištenje SIM kartice?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"U jednom trenutku može biti aktivan samo jedan SIM.\n\nPrebacivanjem na mobilnog operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> neće se otkazati usluga mobilnog operatera <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="1396320209544698027">"Aktivan može biti samo po jedan SIM.\n\nPrebacivanjem na mobilnog operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> neće se otkazati usluga mobilnog operatera <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"U jednom trenutku može biti aktivan samo jedan SIM.\n\nPrebacivanjem se neće otkazati usluga mobilnog operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Prebaci na mobilnog operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Povezivanje s mrežom…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="8341013572582875574">"Prebacivanje na mobilnog operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Nije moguće zamijeniti mobilne operatere"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Nije moguće zamijeniti mobilne operatere zbog greške."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Isključiti operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Isključiti SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Isključivanje SIM-a<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Nije moguće onemogućiti mobilnog operatera"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Nešto nije uredu i nismo mogli onemogućiti vašeg operatera."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Koristiti 2 SIM-a?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Na uređaju mogu istovremeno biti 2 aktivna SIM-a. Da nastavite koristiti po 1 SIM, dodirnite \"Ne, hvala\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Ponovo pokrenuti uređaj?"</string>
    <string name="sim_action_restart_text" msgid="8019300474703571013">"Da započnete, ponovo pokrenite uređaj. Zatim možete dodati još jedan SIM."</string>
    <string name="sim_action_continue" msgid="1688813133152389943">"Nastavi"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Ponovo pokreni"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Ne, hvala"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Prebaci"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Nije moguće aktivirati SIM"</string>
    <string name="dsds_activation_failure_body_msg1" msgid="6303921196869256391">"Izvadite SIM karticu i ponovo je umetnite. Ako se problem ne riješi, ponovo pokrenite uređaj."</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Pokušajte ponovo uključiti SIM. Ako se problem ne riješi, ponovo pokrenite uređaj."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktiviranje mreže"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"Operater <xliff:g id="CARRIER_NAME">%1$s</xliff:g> je aktivan"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Dodirnite da ažurirate postavke SIM-a"</string>
    <string name="sim_card_label" msgid="5632157635124050923">"SIM kartica"</string>
    <string name="erase_sim_dialog_title" msgid="881253002169177016">"Potpuno izbrisati ovaj preuzeti SIM?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Ako potpuno izbrišete ovaj SIM, s ovog uređaja će se ukloniti usluga operatera <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>.\n\nUsluga za operatera <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> neće se otkazati."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Potpuno izbriši"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Potpuno brisanje SIM-a…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Nije moguće potpuno izbrisati SIM"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Nije moguće potpuno izbrisati ovaj SIM zbog greške.\n\nPonovo pokrenite uređaj i pokušajte ponovo."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Povezivanje s uređajem"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplikacija <xliff:g id="APPNAME">%1$s</xliff:g> želi koristiti privremenu WiFi mrežu da se poveže s vašim uređajem"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nije pronađen nijedan uređaj Provjerite jesu li uređaji uključeni i dostupni za povezivanje."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Pokušaj ponovo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Nešto se dogodilo. Ova aplikacija je otkazala zahtjev za odabir uređaja."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Uspješno povezivanje"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Veza nije uspjela"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Prikaži sve"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Traženje uređaja…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Povezivanje s uređajem…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Lijeva"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Desni"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Maska"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Ploča s postavkama"</string>
    <string name="internet_connectivity_panel_title" msgid="2044237561024730108">"Povezivanje na internet"</string>
    <string name="volume_connectivity_panel_title" msgid="8772438444782726321">"Jačina zvuka"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="6067959496888990983">"Nije dostupno dok je aktiviran način rada u avionu"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Nametni način rada na računaru"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Nametanje eksperimentalnog načina rada na računaru na sekundarnim ekranima"</string>
    <!-- no translation found for enable_non_resizable_multi_window (6832903754625404477) -->
    <skip />
    <!-- no translation found for enable_non_resizable_multi_window_summary (3275763753261901999) -->
    <skip />
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Nadjačaj nametanje tamne teme"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Nadjačava funkciju nametanja tamne teme tako da je uvijek uključena"</string>
    <string name="enable_blurs_on_windows_title" msgid="4218144213800778872">"Omogući zamućivanje"</string>
    <string name="enable_blurs_on_windows_summary" msgid="8962906921531490386">"Omogućava zamućivanje prozora na nivou sastavljača. Potrebno je ponovno pokretanje uređaja."</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privatnost"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Odobrenja, aktivnost računa, lični podaci"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Ukloni"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Zadrži"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Ukloniti ovaj prijedlog?"</string>
    <string name="contextual_card_removed_message" msgid="5755438207494260867">"Prijedlog je uklonjen"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="5200381837316691406">"Poništi"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Ponestaje prostora za pohranu. Iskorišteno: <xliff:g id="PERCENTAGE">%1$s</xliff:g> – Slobodno: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Pošalji povratne informacije"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Želite li nam pružiti povratne informacije o ovom prijedlogu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Sljedeći sadržaj je kopiran u međumemoriju: <xliff:g id="COPY_CONTENT">%1$s</xliff:g>"</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="permission_bar_chart_empty_text" msgid="4856719891991325077">"Nijedna aplikacija nije koristila odobrenja"</string>
    <string name="permission_bar_chart_title" msgid="2493212904955611441">"Korištenje odobrenja u posljednja 24 sata"</string>
    <string name="permission_bar_chart_details" msgid="5816698018592357088">"Prikaži sve na kontrolnoj tabli"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="4853396794340896078">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> aplikacija</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> aplikacije</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> aplikacija</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Korištenje pristupačnosti"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="6910643986958263005">
      <item quantity="one"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacija ima potpuni pristup vašem uređaju</item>
      <item quantity="few"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacije imaju potpuni pristup vašem uređaju</item>
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacija ima potpuni pristup vašem uređaju</item>
    </plurals>
    <string name="media_output_panel_title" msgid="5920946795078065159">"Prebacite izlaz"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="6998758947764222915">"Trenutno se reproducira na uređaju <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="media_output_disconnected_status" msgid="5567111639832431865">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> (veza je prekinuta)"</string>
    <string name="media_output_switch_error_text" msgid="603563475910236831">"Nije mog. prebaciti. Dod. da pok. pon."</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Važne informacije"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"NASTAVI"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NE, HVALA"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Lokacija"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="2799241640320172899">"Vaš pružalac usluga može prikupljati podatke o vašoj lokaciji u cilju pružanja ove usluge.\n\nPregledajte pravila privatnosti svog pružaoca usluga."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Možete izgubiti pristup preostalom vremenu ili podacima. Prije uklanjanja, provjerite s pružaocem usluga."</string>
    <string name="keywords_content_capture" msgid="7802155522681936956">"snimanje sadržaja, sadržaj aplikacije"</string>
    <string name="content_capture" msgid="868372905432812238">"Sadržaj aplikacije"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Dozvolite aplikacijama da šalju sadržaj Android sistemu"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Snimi snimak dinamičkog dijela memorije sistema"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Snimanje dinamičkog dijela memorije sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Snimak dinamičkog dijela memorije sistema nije snimljen."</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automatsko snimanje snimaka dinamičkog dijela memorije sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automatski snimi snimke dinamičkog dijela memorije za Android sistem kada koristi previše memorije"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Prekini vezu"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Hitni pozivi"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Vaš operater ne podržava hitne pozive preko funkcije Pozivanje putem WiFi-ja.\nUređaj će se automatski prebaciti na mobilnu mrežu kako bi se uspostavio hitni poziv.\nHitni pozivi su mogući samo na područjima pokrivenim mobilnom mrežom."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Korištenje WiFi-ja za pozive radi poboljšanja kvaliteta"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Pomoćno pozivanje"</string>
    <string name="backup_calling_setting_summary" msgid="451295393447465830">"Ako je <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> nedostupan, koristite SIM za prijenos podat. na mob. mreži da obavljate pozive koristeći <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"pomoćno pozivanje"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Dolazna MMS poruka"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Nije moguće poslati MMS poruku"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Dodirnite da dozvolite MMS poruke na mreži <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> kada je isključen prijenos podataka na mobilnoj mreži"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS poruka"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problem sa SIM kombinacijom"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Korištenje mobilnih operatera <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> možete ograničiti funkcionalnost. Dodirnite da saznate više."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM kombinacija"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informacije o radnim pravilima"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Postavkama upravlja vaš IT administrator"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Obrađivač izvještaja o greškama"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Određuje koja aplikacija obrađuje prečicu za Izvještaj o greškama na uređaju."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Lično"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Posao"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Sistemski zadano"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Ovaj odabir više nije važeći. Pokušajte ponovo."</string>
    <string name="device_controls_sentence" msgid="4887752349920801907">"Kontrole uređaja"</string>
    <string name="quick_controls_lower" msgid="6675573610027367819">"kontrole uređaja"</string>
    <string name="cards_passes_sentence" msgid="1866311782387946944">"Kartice i propusnice"</string>
    <string name="cards_passes_lower" msgid="2429722007109957877">"kartice i propusnice"</string>
    <string name="power_menu_setting_name" msgid="7843519296976254765">"Meni napajanja"</string>
    <string name="power_menu_setting_title" msgid="7716546106215378956">"Meni dugmeta za uključivanje"</string>
    <string name="power_menu_cards_passes" msgid="1707852019651773645">"Prikaži kartice i propusnice"</string>
    <string name="power_menu_device_controls" msgid="5114816270328063924">"Prikaži kontrole uređaja"</string>
    <string name="power_menu_cards_passes_device_controls" msgid="8645794247280620106">"Prikaži kartice, propusnice i kontrole uređaja"</string>
    <string name="power_menu_lock_screen_category" msgid="1478249026305417128">"Zaključavanje ekrana"</string>
    <string name="power_menu_none" msgid="4620640577918731270">"Ne prikazuj nikakav sadržaj"</string>
    <string name="power_menu_privacy" msgid="7900052501075197854">"Osjetljivi sadržaj"</string>
    <string name="power_menu_privacy_show" msgid="2112741022037054383">"Prikaži kartice i kontrole kada je uređaj zaključan"</string>
    <string name="power_menu_privacy_show_controls" msgid="8294874046577167797">"Prikaži kontrole na zaključanom ekranu"</string>
    <string name="power_menu_privacy_show_cards" msgid="8937303188629541026">"Prikazuj kartice kada je uređaj zaključan"</string>
    <string name="power_menu_privacy_hide" msgid="1617102911157977095">"Sakrij kartice i kontrole kada je uređaj zaključan"</string>
    <string name="power_menu_privacy_not_secure" msgid="6247119934128206924">"Da koristite, prvo postavite zaključavanje ekrana"</string>
    <string name="device_controls_setting_toggle" msgid="8972005569207737469">"Prikaži kontrole uređaja"</string>
    <string name="cards_passes_setting_toggle" msgid="3380984848045396695">"Prikaz kartica i propusnica"</string>
    <string name="device_controls_setting_subtitle" msgid="4388544861427973600">"Da pristupite kontrolama za povezane uređaje, držite dugme za uključivanje"</string>
    <string name="cards_passes_setting_subtitle" msgid="4427459738229697469">"Pritisnite i držite dugme za otključavanje/zaključavanje da pristupite stvarima poput načina plaćanja i karti za ukrcaj."</string>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="media_output_panel_stop_casting_button" msgid="6094875883164119035">"Zaustavi emitiranje"</string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Isključiti VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Time isključujete i 5G vezu.\nTokom glasovnog poziva ne možete koristiti internet i neke aplikacije možda neće raditi."</string>
    <string name="no_5g_in_dsds_text" product="default" msgid="772747677303920132">"Kada koristite 2 SIM-a, ovaj telefon će biti ograničen na 4G. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="no_5g_in_dsds_text" product="tablet" msgid="4757328474425714624">"Kada koristite 2 SIM-a, ovaj tablet će biti ograničen na 4G. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="no_5g_in_dsds_text" product="device" msgid="6983783505032683314">"Kada koristite 2 SIM-a, ovaj uređaj će biti ograničen na 4G. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Obustavi izvršenja za aplikacije u keš memoriji"</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Dozvolite preklapanja ekrana na Postavkama"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Dozvolite aplikacijama koje mogu prikazivati preko drugih aplikacija da preklapaju ekrane Postavki"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Mediji"</string>
    <string name="media_controls_summary" msgid="3573121049460596520">"Media plejer u Brzim postavkama"</string>
    <string name="media_controls_resume_description" msgid="7702723104730495227">"Prikažite Medija plejer produženi period da s lakoćom nastavite reprodukciju"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Sakrij plejer"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Prikaži plejer"</string>
    <string name="media_controls_no_players" msgid="3493023121892175946">"Nema dostupnih plejera"</string>
    <string name="media_controls_apps_title" msgid="9129092193224838008">"Odobrene aplikacije"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"mediji"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth će se uključiti"</string>
    <string name="bluetooth_setting_on" msgid="4808458394436224124">"Uključeno"</string>
    <string name="bluetooth_setting_off" msgid="4965493913199554789">"Isključeno"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM-ovi"</string>
    <string name="airplane_safe_networks" msgid="6057114281183247124">"Prikaži mreže za način rada u avionu"</string>
    <string name="airplane_safe_networks_summary" msgid="4879620804022818385">"Pronađite i povežite se s mrežama u načinu rada u avionu."</string>
    <string name="keywords_airplane_safe_networks" msgid="5902708537892978245">"avion, sigurno za rad u avionu"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Pozivi i SMS"</string>
    <string name="calls_and_sms_category" msgid="2021321997884906046">"Pozivanje putem WiFi-ja"</string>
    <!-- no translation found for calls_sms_wfc_summary (3940529919408667336) -->
    <skip />
    <!-- no translation found for calls_sms_footnote (8051604228144899434) -->
    <skip />
    <string name="calls_preference_title" msgid="7536882032182563800">"Pozivi"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferirano"</string>
    <string name="calls_sms_calls_preferred" msgid="252913858812799809">"preferiraju se pozivi"</string>
    <string name="calls_sms_sms_preferred" msgid="5826706870873784062">"preferiraju se SMS-ovi"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nedostupno"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Nema SIM-a"</string>
    <string name="network_and_internet_preferences_title" msgid="8038469368705591439">"Postavke"</string>
    <string name="network_and_internet_preferences_summary" msgid="613207494152304537">"Povežite se s javnim mrežama"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"mrežna veza, internet, bežični, podaci, wifi, wi-fi, wi fi, celularni, mobilni, mobilni operater, 4g, 3g, 2g, lte"</string>
    <string name="view_airplane_safe_networks" msgid="9170023210981508906">"Prikaži mreže načina rada u avionu"</string>
    <string name="viewing_airplane_mode_networks" msgid="4548508852659577531">"Prikaz mreža za način rada u avionu"</string>
    <string name="turn_off_airplane_mode" msgid="7141986366534514443">"Isključi način rada u avionu"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Vratiti internetsku vezu na zadano?"</string>
    <string name="reset_internet_text" product="default" msgid="8797910368942544453">"Ovim će se prekinuti vaš telefonski poziv"</string>
    <string name="reset_internet_text" product="tablet" msgid="8797910368942544453">"Ovim će se prekinuti vaš telefonski poziv"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Vraćanje internetske veze na zadano…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Popravi povezivost"</string>
    <string name="airplane_mode_network_available" msgid="1059499681300395240">"Dostupne su mreže za način rada u zrakoplovu"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Da biste se prebacili na drugu mrežu, odspojite ethernet"</string>
    <!-- no translation found for cannot_switch_networks_while_connected (3867944849171754777) -->
    <skip />
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g>/<xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Povezano"</string>
    <string name="mobile_data_off_summary" msgid="3841411571485837651">"Nije se moguće automatski povezati s internetom"</string>
    <string name="non_carrier_network_unavailable" msgid="9031567407964127997">"Druge mreže nisu dostupne"</string>
    <string name="all_network_unavailable" msgid="1163897808282057496">"Nema dostupnih mreža"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nedostupno jer je uključen način rada za spavanje"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Poništavanje važnosti obavještenja je završeno."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikacije"</string>
    <string name="bluetooth_message_access_notification_content" msgid="2986108412562309009">"Nepouzdani uređaj želi pristupiti vašim porukama. Dodirnite za detalje."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Dozvoliti pristup porukama?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="2304761898608701739">"Nepouzdani Bluetooth uređaj, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, želi pristupiti vašim porukama.\n\nNiste se prije povezivali s uređajem <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="4280361621526852063">"Nepouzdani uređaj želi pristupiti vašim kontaktima i zapisniku poziva. Dodirnite za detalje."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Dozvoliti pristup kontaktima i zapisniku poziva?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="4766700015848574532">"Nepouzdani Bluetooth uređaj, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, želi pristupiti vašim kontaktima i zapisniku poziva. To obuhvata podatke o dolaznim i odlaznim pozivima.\n\nNiste se prije povezivali s uređajem <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Osvjetljenje"</string>
    <string name="category_name_lock_display" msgid="7478785189102882266">"Zaključavanje ekrana"</string>
    <string name="category_name_visibility" msgid="4485030512199246405">"Vidljivost"</string>
    <string name="category_name_color" msgid="937514550918977151">"Boja"</string>
    <string name="category_name_others" msgid="2366006298768550310">"Ostalo"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Općenito"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Pogledajte sve aplikacije"</string>
    <!-- no translation found for smart_forwarding_title (8368634861971949799) -->
    <skip />
    <!-- no translation found for smart_forwarding_summary_enabled (3341062878373185604) -->
    <skip />
    <!-- no translation found for smart_forwarding_summary_disabled (5033880700091914809) -->
    <skip />
    <!-- no translation found for smart_forwarding_ongoing_title (962226849074401228) -->
    <skip />
    <!-- no translation found for smart_forwarding_ongoing_text (2189209372407117114) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_title (1859891191023516080) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_text (5370431503707373653) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_not_activated_text (997396203001257904) -->
    <skip />
    <!-- no translation found for smart_forwarding_input_mdn_title (5105463748849841763) -->
    <skip />
    <!-- no translation found for smart_forwarding_input_mdn_dialog_title (7542216086697868415) -->
    <skip />
    <!-- no translation found for smart_forwarding_missing_mdn_text (2907314684242542226) -->
    <skip />
    <!-- no translation found for smart_forwarding_missing_alert_dialog_text (7870419247987316112) -->
    <skip />
</resources>
