<?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">"Izradi"</string>
    <string name="allow" msgid="3763244945363657722">"Dopusti"</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>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Dodirnite za prikaz informacija"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Još # korak i postat ćete razvojni programer.}one{Još # korak i postat ćete razvojni programer.}few{Još # koraka i postat ćete razvojni programer.}other{Još # koraka i postat ćete razvojni programer.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Sad ste razvojni programer!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nema potrebe, već ste razvojni programer."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Najprije omogućite opcije za razvojne programere."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sustav"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Upotrebljava se"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ne radi"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio je isključen"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Bez roaminga"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Niste povezani"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Povezivanje"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Povezan"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Obustavljeno"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Nepoznato"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Pregled"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Smanji"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Povećaj"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Koristi automatsko zakretanje"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Prepoznavanje lica koristi prednju kameru radi poboljšanja točnosti automatskog zakretanja. Slike se nikad ne pohranjuju i ne šalju Googleu."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Vidljivo svim Bluetooth uređajima u blizini (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Vidljivo svim Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nije vidljiv drugim Bluetooth uređajima"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Vidljivo samo uparenim uređajima"</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_rename_device" msgid="4219655243836021443">"Preimenujte ovaj uređaj"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Preimenuj"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Prekinuti vezu uređaja?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Uparite novi uređaj"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Upari desno uho"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Upari lijevo uho"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Uparite drugo uho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="7936892941892347102">"Lijevo slušno pomagalo je povezano.\n\nDa biste uparili desno, provjerite je li uključeno i spremno za uparivanje."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="8242208936062915941">"Desno slušno pomagalo je povezano.\n\nDa biste uparili lijevo, provjerite je li uključeno i spremno za uparivanje."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Upari desno uho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Upari lijevo uho"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Za sve dostupne slušne uređaje"</string>
    <string name="bluetooth_device_controls_title" msgid="4293399064818086587">"Prečaci i kompatibilnost sa slušnim pomagalima"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Za ovaj uređaj"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audioizlaz"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"O audioizlazu"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Usmjerite zvukove prema svojem slušnom aparatu ili zvučniku telefona"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Povezano"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Melodija zvona i alarmi"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Zvuk tijekom poziva"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Mediji"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Obavijesti i drugi zvukovi sustava"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Prema zadanim postavkama audioizlaz se određuje na temelju pojedinačnih aplikacija"</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">"U blizini nema Bluetooth uređaja."</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 uparivanje s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</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 biste uključili"</string>
    <string name="device_picker" msgid="2427027896389445414">"Odaberite 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 isključ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 uključiti Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Uključivanje Bluetootha…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Isključivanje Bluetootha?"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Zatražena je Bluetooth veza"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Zahtjev za pristup telefonskom imeniku"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Zahtjev za pristup porukama"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Drugim uređajima vidljiv kao \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\""</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Uključite Bluetooth da biste se povezali 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_disable_a2dp_hw_offload" msgid="5942913792817797541">"Onemogući Bluetooth A2DP hardversko rasterećenje"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Onemogući uklanjanje Bluetooth LE audio hardvera"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Ponovo pokrenuti uređaj?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Ponovo pokrenite uređaj da biste promijenili tu postavku."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Ponovo pokreni"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Odustani"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Onemogućivanje Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Onemogućuje audio značajku Bluetooth LE ako uređaj podržava mogućnosti LE audio hardvera."</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Omogući popis dopuštenih za Bluetooth LE Audio"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Omogućivanje značajke popisa dopuštenih za Bluetooth LE Audio."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Medijski uređaji"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Uređaji za pozive"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Ostali uređaji"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Spremljeni uređaji"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth će se uključiti radi uparivanja"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Postavke povezivanja"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Prethodno povezano"</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="stylus_device_details_title" msgid="7618295136015480864">"Pisaljka"</string>
    <string name="stylus_default_notes_app" msgid="3896158797687806941">"Zadana aplikacija za bilješke"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Pisanje u tekstualnim poljima"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Zanemari sve pritiske pisaljke na gumb"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Pisaljka"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum i vrijeme"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Očisti"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Priključak proxy poslužitelja"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Zaobiđi proxy za"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Vrati zadano"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Gotovo"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Naziv hosta proxy poslužitelja"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Pažnja"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"U redu"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Naziv hosta koji ste upisali nije valjan."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Popis za isključivanje koji ste napisali nije pravilno formatiran. Unesite popis isključenih domena odvojenih zarezima."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Morate dovršiti polje priključka."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Polje priključka mora biti prazno ako je i polje hosta prazno."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Upisani priključak nije valjan."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Preglednik upotrebljava HTTP proxy poslužitelj, ali druge aplikacije ne mogu ga upotrebljavati."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL za PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Pinganje naziva hosta (www.google.com) IPv4:"</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="skip_label" msgid="6380034601349015895">"Preskoči"</string>
    <string name="next_label" msgid="1248293387735652187">"Dalje"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Jezici"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Redoslijed preferiranih jezika"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Jezik sustava"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Ukloni"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Dodaj jezik"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Jezik"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Željeni jezik"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Jezici aplikacija"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Postavite jezik za svaku aplikaciju"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Jezik aplikacije"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Predloženi jezici"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Svi jezici"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Jezik sustava"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Zadane postavke sustava"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Odabir jezika za ovu aplikaciju nije dostupan u postavkama."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Jezik se može razlikovati od jezika dostupnih u aplikaciji. Neke aplikacije možda ne podržavaju tu postavku."</string>
    <string name="desc_app_locale_selection_supported" msgid="6149467826636295127">"Ovdje se prikazuju samo aplikacije koje podržavaju odabir jezika."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Vaš sustav, aplikacije i web-lokacije upotrebljavaju prvi podržani jezik s popisa preferiranih jezika."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Da biste odabrali jezik za svaku aplikaciju, otvorite postavke jezika aplikacije."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Saznajte više o jezicima aplikacije"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Promijeniti jezik sustava u %s?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Promijenit će se postavke uređaja i regionalne postavke."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Promijeni"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s nije dostupan"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Taj se jezik ne može upotrebljavati kao jezik sustava, no postavili ste ga kao preferirani jezik za aplikacije i web-lokacije."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regionalne postavke"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Odredite kako će se prikazivati mjerne jedinice i brojke"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Obavijestite aplikacije o svojim regionalnim preferencijama kako bi mogle personalizirati vaš doživljaj."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplikacije će upotrebljavati vaše regionalne preferencije tamo gdje to bude moguće."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatura"</string>
    <string name="calendar_preferences_title" msgid="8312485828206542600">"Kalendar"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Prvi dan u tjednu"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Postavke brojeva"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"Koristi zadanu vrijednost aplikacije"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celzij (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Nedjelja"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Ponedjeljak"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Utorak"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Srijeda"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Četvrtak"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Petak"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Subota"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Ako aplikacija ne podržava regionalne postavke, aplikacija će upotrebljavati zadane postavke zemlje/jezika."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Saznajte više o postavkama jezika."</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Želite li ukloniti odabran jezik?}one{Želite li ukloniti odabran jezik?}few{Želite li ukloniti odabrana jezika?}other{Želite li ukloniti odabranih jezika?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekst će se prikazivati na nekom drugom jeziku."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Ne možete ukloniti sve jezike"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Zadržite barem jedan preferirani jezik"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Nije dostupno kao jezik sustava"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Premještanje gore"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Premještanje dolje"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Premještanje na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Premještanje na dno"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Uklanjanje jezika"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Odabir aktivnosti"</string>
    <string name="cancel" msgid="5780102414089664898">"Odustani"</string>
    <string name="okay" msgid="4827099303045669054">"U redu"</string>
    <string name="forget" msgid="3754013654135912783">"Zaboravi"</string>
    <string name="save" msgid="3125033126936493822">"Spremi"</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="remove" msgid="1028414219245072102">"Ukloni"</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čac postavki"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Način rada u zrakoplovu"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bežično povezivanje i mreže"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Poveži se s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Poveži se s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Možda se naplaćuju dodatne naknade za roaming."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Automatsko postavljanje vremena"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Postavi automatski"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Lokacija će se upotrebljavati za postavljanje vremenske zone kad je ovaj prekidač uključen"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Koristi zadani lokalni 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živanje regije"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Regija"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Odabir razlike u odnosu na UTC"</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_first_sentence" msgid="1326664252091302458">"Upotrebljava <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> počinje <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Upotrebljava <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nema ljetnog vremena."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Ljetno računanje vremena"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardno računanje vremena"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Odaberite po regiji"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Odabir u odnosu na UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Zaključaj nakon isteka vremena čekanja"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon isteka vremena čekanja"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Odmah nakon isteka vremena čekanja, osim kad 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 čekanja, osim kad ga <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> drži otključanim"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Dodavanje teksta na zaklj. zaslon"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ništa"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Na primjer, Markov Android."</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>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Uključeno – # aplikacija ima pristup lokaciji}one{Uključeno – # aplikacija ima pristup lokaciji}few{Uključeno – # aplikacije imaju pristup lokaciji}other{Uključeno – # aplikacija ima pristup lokaciji}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Učitavanje…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Aplikacije s dopuštenjem za uređaje u blizini mogu odrediti približni položaj povezanih uređaja."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Pristup lokaciji isključen je za aplikacije i usluge. Lokacija vašeg uređaja i dalje se može slati djelatnicima hitnih službi kada nazovete broj hitne službe ili na njega pošaljete SMS."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Saznajte više o postavkama lokacije."</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 vjerodajnice"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Zaključan zaslon"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Što prikazati"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nedostupna"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Sigurnosni status"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Zaključavanje zaslona, Pronađi moj uređaj, sigurnost aplikacija"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Sigurnost i privatnost"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Sigurnost aplikacija, zaključavanje uređaja, dopuštenja"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Lice dodano"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Potrebno je postavljanje"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Otključavanje licem"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Otključavanje licem za posao"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Kako postaviti otključavanje licem"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Postavljanje otključavanja licem"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Autentificirajte se licem"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Započnite"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Ako je otključavanje licem za pristupačnost isključeno, neki koraci za postavljanje možda neće pravilno funkcionirati s TalkBackom."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Natrag"</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 postav. za pristupačnost"</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">"Odustani"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Ne, hvala"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Prihvaćam"</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čavanje licem"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Dopuštanje otključavanja licem"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Autentificirajte se licem"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Otključajte telefon ili odobrite kupnje svojim licem.\n\nNapomena: ovaj uređaj ne možete otključati licem. Za više informacija obratite se administratoru organizacije."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Licem možete otključati telefon, autorizirati kupnje ili se prijaviti u aplikacije"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Postavite lice u središte kruga"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Preskoči"</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">"U redu"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Isteklo je vremensko ograničenje za registraciju lica. Pokušajte ponovo."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Registracija lica nije uspjela."</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="6835778900387289683">"Poboljšajte uspješnost otključavanja licem"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Ponovo postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Ponovo postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Poboljšajte sigurnost i rad značajke"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Postavite otključavanja licem"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Izbrišite trenutačni model lica da biste ponovo postavili otključavanje licem.\n\nModel lica trajno će se i sigurno izbrisati.\n\nNakon brisanja trebat će vam PIN, uzorak ili zaporka da biste otključali telefon ili izvršili autentifikaciju u aplikacijama."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Izbrišite trenutačni model lica da biste ponovo postavili otključavanje licem.\n\nModel lica trajno će se i sigurno izbrisati.\n\nNakon brisanja trebat će vam otisak prsta, PIN, uzorak ili zaporka da biste otključali telefon ili izvršili autentifikaciju u aplikacijama."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Koristi otključ. licem za"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Kada se upotrebljava 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 biste otključali 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="3498729789625461914">"Za upotrebu otključavanja licem u aplikacijama uvijek tražite potvrdu"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Izbriši model lica"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Postavite otključavanje licem"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Želite li izbrisati model lica?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Vaš model lica izbrisat će se trajno i sigurno.\n\nNakon brisanja trebat će vam PIN, uzorak ili zaporka da biste otključali telefon ili za autentifikaciju u aplikacijama."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Model lica trajno će se i sigurno izbrisati.\n\nNakon brisanja trebat će vam PIN, uzorak ili zaporka da biste otključali telefon."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Otključajte telefon licem"</string>
    <!-- no translation found for security_settings_fingerprint (6387775386189204201) -->
    <skip />
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Otisak prsta"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Kad se koristi otključavanje otiskom prsta"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Otisak za posl. profil"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Dodajte otisak prsta"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Dodan je otisak prsta}one{Dodan je # otisak prsta}few{Dodana su # otiska prsta}other{Dodano je # otisaka prsta}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Potrebno je postavljanje"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Postavljanje otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Dopuštanje otključavanja otiskom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Upotreba otiska prsta"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Saznajte više o otključavanju otiskom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Kontrola je u vašim rukama"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Kontrola je u vašim rukama i rukama vašeg djeteta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Ne zaboravite"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Otključajte telefon ili odobrite kupnje otiskom prsta.\n\nNapomena: ovaj uređaj ne možete otključati otiskom prsta. Za više informacija obratite se administratoru organizacije."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Odustani"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Ne, hvala"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Prihvaćam"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Želite li preskočiti otisak prsta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Postavljanje otisaka prstiju traje samo jednu ili dvije minute. Ako to preskočite, otiske prstiju možete dodati kasnije u postavkama."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Kada se prikaže ta ikona, upotrijebite otisak prsta za autentifikaciju, na primjer radi prijave u aplikacije ili odobravanja kupnje"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Napomena"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Kako to funkcionira"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Otključavanje otiskom prsta izrađuje jedinstveni model vašeg otiska prsta radi potvrde vašeg identiteta. Da biste izradili model otiska prsta tijekom postavljanja, snimit ćete slike svojeg otiska prsta iz različitih položaja."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Otključavanje otiskom prsta izrađuje jedinstveni model otiska prsta vašeg djeteta radi potvrđivanja njegovog identiteta. Da bi izradilo model otiska prsta tijekom postavljanja, dijete će snimiti slike svojeg otiska prsta iz različitih položaja."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Za najbolje rezultate koristite zaštitu zaslona s certifikatom Made for Google. Vaš otisak prsta možda neće funkcionirati s drugim zaštitama zaslona."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Za najbolje rezultate koristite zaštitu zaslona s certifikatom Made for Google. Otisak prsta vašeg djeteta možda neće funkcionirati s drugim zaštitama zaslona."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Otključavanje satom"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Kad postavite otključavanje licem i otključavanje otiskom prsta, telefon će tražiti vaš otisak prsta kad nosite masku ili se nalazite u tamnom prostoru.\n\nMožete otključati pomoću sata kada se vaše lice ili otisak prsta ne prepoznaju."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Možete otključati pomoću sata kada se vaš otisak prsta ne prepozna."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Možete otključati pomoću sata kada se vaše lice ili otisak prsta ne prepoznaju."</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Korištenje lica ili sata"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Korištenje otiska prsta ili sata"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Korištenje lica, otiska prsta ili sata"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Korištenje sata"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Postavljanje prvo otključavanja licem ili otiskom prsta"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Možete otključati pomoću sata kad se vaše lice ili otisak prsta ne prepoznaju."</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Postavljanje prvo otključavanja otiskom prsta"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Možete otključati pomoću sata kada se vaš otisak prsta ne prepozna"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Postavljanje prvo otključavanja licem"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Možete otključati pomoću sata kada se vaše lice ne prepozna"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Postavi"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Dodani su otisak prsta i sat <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Dodani su otisci prstiju i sat <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Dodano je lice i sat <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Dodani su lice, otisak prsta i sat <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Dodani su lice, otisci prstiju i sat <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Otključavanje licem i otiskom prsta"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Otključavanje licem i otiskom prsta za rad"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Potrebno je postavljanje"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Dodano je lice i otisci prsta"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Dodano je lice i otisak prsta"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Kad postavite otključavanje licem i otključavanje otiskom prsta, telefon će tražiti vaš otisak prsta kad nosite masku ili se nalazite u tamnom prostoru."</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Načini otključavanja"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Upotrijebite lice ili otisak prsta za"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Otključavanje telefona"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Potvrđivanje identiteta u aplikacijama"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Pomoću lica"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Pomoću otiska prsta"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Pomoću lica ili otiska prsta"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"U redu"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Ne možete postaviti otključavanje licem"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Zatvorite podijeljeni zaslon da biste postavili otključavanje licem"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Postavljanje otiska prsta nije uspjelo"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Zatvorite podijeljeni zaslon da biste postavili otključavanje otiskom prsta"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"U redu"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Želite li preskočiti zaključavanje zaslona?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Svejedno preskoči"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Natrag"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Preskoči"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Odustani"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dodirnite senzor"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Dodirnite tipku za uključivanje/isključivanje bez pritiska"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Kako postaviti otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Nalazi se na stražnjoj strani telefona. Upotrijebite kažiprst."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Senzor otiska prsta nalazi se na zaslonu. Na sljedećem zaslonu snimit ćete svoj otisak prsta."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Započni"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Pomičite prst po zaslonu da biste pronašli senzor. Dodirnite i zadržite senzor otiska prsta."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustracija uređaja i lokacije senzora otiska 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">"U redu"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Pokušajte ponovo"</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 kada osjetite vibraciju"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Zadržite jagodicu prsta na senzoru dok ne osjetite vibraciju"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Bez pritiskanja tipke zadržite prst na senzoru dok ne osjetite vibraciju.\n\nSvaki put kad je osjetite, lagano pomaknite prst. To pomaže da se snimi veći dio otiska prsta."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Dodirnite i zadržite senzor otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Podignite i ponovo dodirnite"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Još jednom"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Slijedite ikonu otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Nastavite podizati prst da biste dodali različite dijelove otiska prsta"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Dodirnite i zadržite svaki put kada se ikona otiska prsta pomakne. To pomaže da ste snimi veći dio otiska prsta."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Postavite vrh prsta na senzor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Postavite lijevi rub prsta"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Postavite desni rub prsta"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Postavite središnji dio prsta na senzor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Postavite vrh prsta na senzor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Postavite lijevi rub prsta na senzor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"I na kraju, postavite desni rub prsta na senzor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Postavite rub prsta na senzor i zadržite ga, a zatim prijeđite na drugu stranu"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"To pomaže da ste snimi veći dio otiska prsta"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Otisak prsta prijavljen je <xliff:g id="PERCENTAGE">%d</xliff:g> posto"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Prijavljeno <xliff:g id="PERCENTAGE">%d</xliff:g> posto"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Prijava otiska prsta: <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Otisak prsta je dodan"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Dodirnite za otključavanje bilo kad"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Dodirnite senzor da biste otključali uređaj, čak i kad je zaslon isključen. Time se povećava mogućnost slučajnog otključavanja."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Zaslon, otključati"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Kasnije ću"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Podignite i ponovo dodirnite"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Postavite rub prsta na senzor i zadržite ga, a zatim prijeđite na drugu stranu"</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">"Odlučili ste se za otisak prsta kao jedan od načina za otključavanje telefona. Ako sad preskočite, morat ćete ga postaviti kasnije. Postavljanje traje samo otprilike jednu minutu."</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Preskočiti postavljanje PIN-a?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Preskočiti postavljanje PIN-a i lica?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Preskočiti postavljanje PIN-a i otiska prsta?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Preskočiti postavljanje PIN-a, lica i otiska prsta?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Preskočiti postavljanje zaporke?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Preskočiti postavljanje zaporke i lica?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Preskočiti postavljanje zaporke i otiska prsta?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Preskočiti postavljanje zaporke, lica i otiska prsta?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Preskočiti postavljanje uzorka?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Preskočiti postavljanje uzorka i lica?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Preskočiti postavljanje uzorka i otiska prsta?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Preskočiti postav. uzorka, lica i otiska prsta?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Postavi zaključavanje zaslona"</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">"Kažiprstom dodirnite senzor na stražnjoj strani telefona."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="5796228438604723279">"Registracija nije dovršena"</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Vrijeme za postavljanje otiska prsta je isteklo"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="467965101751652156">"Pokušajte ponovo odmah ili ga postavite kasnije u postavkama"</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"Registracija otiska prsta nije uspjela. Pokušajte ponovo ili prislonite neki drugi prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Dodajte drugi"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Dalje"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Opcija zaključavanja zaslona je onemogućena. Da biste saznali više, obratite se administratoru svoje organizacije."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"I dalje možete upotrebljavati otisak prsta za autorizaciju kupnji i pristup aplikacijama."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Podignite prst, a zatim ponovo dodirnite senzor"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="598502302101068608">"Senzor otiska prsta ne može se koristiti. Posjetite davatelja usluga popravaka"</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Više sigurnosnih postavki"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Zaključavanje poslovnog profila, šifriranje i drugo"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Šifriranje, vjerodajnice i drugo"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"sigurnost, više sigurnosnih postavki, više postavki, napredne sigurnosne postavke"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Više postavki privatnosti"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Više sigurnosti i privatnosti"</string>
    <string name="security_header" msgid="961514795852103424">"Sigurnost"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privatnost"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Poslovni profil"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Maksimalni broj otisaka prstiju koji se može dodati iznosi <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste maksimalan broj otisaka prstiju"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nije moguće dodati više otisaka prstiju"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Izbrišite <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Otiskom prsta nećete moći otključati poslovni profil, autorizirati kupnje niti se prijaviti u poslovne aplikacije."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Šifriranje"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Šifrirano"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Postavljanje zaključavanja zaslona"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Za dodatnu sigurnost postavite PIN, uzorak ili zaporku za ovaj uređaj."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Postavite zaključavanje zaslona"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="5718363966239208505">"Uređaj nema zaključavanje zaslona"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Za dodatnu sigurnost postavite PIN, uzorak ili zaporku za ovaj uređaj."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Zaštitite telefon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Dodajte otisak prsta za otključavanje"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Zaključavanje zaslona"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Odaberite zaključ. zaslona"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Odabir novog zaključavanja zaslona"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Zaključavanje za poslovne aplikacije"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Novo zaključ. poslov. prof."</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Radi dodatne sigurnosti postavite pričuvno zaključavanje zaslona"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Odaberite pričuvni način zaključavanja zaslona"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Ako zaboravite radnju za zaključavanje zaslona, IT administrator ga ne može poništiti."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Postavite zasebno zaključavanje za poslovne aplikacije"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Ako ne znate čime ste ih zaključali, zamolite administratora da ga poništi"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opcije zaključavanja zaslona"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opcije zaključavanja zaslona"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Automatska potvrda otključavanja"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Automatski otključajte ako unesete ispravan PIN od šest ili više znamenki. To je malo nesigurniji način od dodira na Enter za potvrdu."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Automatska potvrda ispravnog PIN-a"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Potvrđivanje PIN-a dodirom na Enter sigurnije je od automatske potvrde"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Unesite PIN uređaja da biste omogućili automatsku potvrdu"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Unesite PIN uređaja da biste onemogućili automatsku potvrdu"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zaključavanje zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zaklj. poslovnog profila"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ništa"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Prelazak prstom"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Uzorak"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Zaporka"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ne sada"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Trenutačno zaključavanje zaslona"</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 zaporka"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Nastavi bez otiska prsta"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="3117316407679805330">"Otključavanje licem + uzorak"</string>
    <string name="face_unlock_set_unlock_pin" msgid="5300188327595503657">"Otključavanje licem + PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8395722611524617956">"Otključavanje licem + zaporka"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Nastavite bez otključavanja licem"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Uzorak • lice • otisak prsta"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"PIN • lice • otisak prsta"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Zaporka • lice • otisak prsta"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Nastavite bez otključavanja licem ili otiskom prsta"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ništa"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Prelazak 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">"Zaporka"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Želite li izbrisati zaključavanje zaslona?"</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="6246242612158828147">"Uzorak štiti vaš telefon ako ga izgubite ili ga netko ukrade"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Uzorak štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se također briše model otiska prsta pohranjen na vašem uređaju. Nećete se moći autentificirati otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Uzorak štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Uzorak štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se briše model otiska prsta pohranjen na vašem uređaju. I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem ni otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN štiti vaš telefon ako ga izgubite ili ga netko ukrade"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se također briše model otiska prsta pohranjen na vašem uređaju. Nećete se moći autentificirati otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se briše model otiska prsta pohranjen na vašem uređaju. I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem ni otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Zaporka štiti vaš telefon ako ga izgubite ili ga netko ukrade"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Zaporka štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se također briše model otiska prsta pohranjen na vašem uređaju. Nećete se moći autentificirati otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Zaporka štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Zaporka štiti vaš telefon ako ga izgubite ili ga netko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se briše model otiska prsta pohranjen na vašem uređaju. I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem ni otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Značajke zaštite uređaja neće funkcionirati bez zaključavanja zaslona."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Značajke zaštite uređaja neće funkcionirati bez zaključavanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se također briše model otiska prsta pohranjen na vašem uređaju. Nećete se moći autentificirati otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Značajke zaštite uređaja neće funkcionirati bez zaključavanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Značajke zaštite uređaja neće funkcionirati bez zaključavanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>Time se briše model otiska prsta pohranjen na vašem uređaju. I vaš model lica izbrisat će se trajno i sigurno. Nećete se moći autentificirati licem ni otiskom prsta u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Izbriši"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje snažniji PIN ili zaporku i bez toga možda neće pravilno funkcionirati"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje novi PIN ili zaporku i bez toga možda neće pravilno funkcionirati"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje novi uzorak, PIN ili zaporku i bez toga možda neće pravilno funkcionirati"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje novo zaključavanje zaslona"</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 će se podaci izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ako pri sljedećem pokušaju unesete netočan uzorak, izbrisat će se podaci s ovog uređaja"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ako pri sljedećem pokušaju unesete netočan PIN, izbrisat će se podaci s ovog uređaja"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ako pri sljedećem pokušaju unesete netočnu zaporku, izbrisat će se podaci s ovog uređaja"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ako pri sljedećem pokušaju unesete netočan uzorak, ovaj će se korisnik izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ako pri sljedećem pokušaju unesete netočan PIN, ovaj će se korisnik izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ako pri sljedećem pokušaju unesete netočnu zaporku, ovaj će se korisnik izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ako pri sljedećem pokušaju unesete netočan uzorak, izbrisat će se vaš poslovni profil i njegovi podaci."</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ako pri sljedećem pokušaju unesete netočan PIN, izbrisat će se vaš poslovni profil i njegovi podaci."</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ako pri sljedećem pokušaju unesete netočnu zaporku, izbrisat će se vaš poslovni profil i njegovi podaci."</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Mora sadržavati najmanje # znak}one{Mora sadržavati najmanje # znak}few{Mora sadržavati najmanje # znaka}other{Mora sadržavati najmanje # znakova}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Ako upotrebljavate samo brojeve, potrebna je najmanje jedna znamenka}one{Ako upotrebljavate samo brojeve, potrebna je najmanje # znamenka}few{Ako upotrebljavate samo brojeve, potrebne su najmanje # znamenke}other{Ako upotrebljavate samo brojeve, potrebno je najmanje # znamenki}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN mora sadržavati najmanje # znamenku}one{PIN mora sadržavati najmanje # znamenku}few{PIN mora sadržavati najmanje # znamenke}other{PIN mora sadržavati najmanje # znamenki}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN mora sadržavati najmanje # znamenku, no radi dodatne sigurnosti preporučuje se {minAutoConfirmLen}-znamenkasti PIN}one{PIN mora sadržavati najmanje # znamenku, no radi dodatne sigurnosti preporučuje se {minAutoConfirmLen}-znamenkasti PIN}few{PIN mora sadržavati najmanje # znamenke, no radi dodatne sigurnosti preporučuje se {minAutoConfirmLen}-znamenkasti PIN}other{PIN mora sadržavati najmanje # znamenki, no radi dodatne sigurnosti preporučuje se {minAutoConfirmLen}-znamenkasti PIN}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Mora sadržavati manje od # znaka}one{Mora sadržavati manje od # znaka}few{Mora sadržavati manje od # znaka}other{Mora sadržavati manje od # znakova}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Mora sadržavati manje od # znamenke}one{Mora sadržavati manje od # znamenke}few{Mora sadržavati manje od # znamenke}other{Mora sadržavati manje od # znamenki}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Administrator uređaja ne dopušta upotrebu nedavnog PIN-a"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Unos ne smije sadržavati nevažeće znakove"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Mora sadržavati najmanje 1 slovo}one{Mora sadržavati najmanje # slovo}few{Mora sadržavati najmanje # slova}other{Mora sadržavati najmanje # slova}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Mora sadržavati najmanje 1 malo slovo}one{Mora sadržavati najmanje # malo slovo}few{Mora sadržavati najmanje # mala slova}other{Mora sadržavati najmanje # malih slova}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Mora sadržavati najmanje 1 veliko slovo}one{Mora sadržavati najmanje # veliko slovo}few{Mora sadržavati najmanje # velika slova}other{Mora sadržavati najmanje # velikih slova}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Mora sadržavati najmanje 1 znamenku}one{Mora sadržavati najmanje # znamenku}few{Mora sadržavati najmanje # znamenke}other{Mora sadržavati najmanje # znamenki}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Mora sadržavati najmanje 1 posebni simbol}one{Mora sadržavati najmanje # posebni simbol}few{Mora sadržavati najmanje # posebna simbola}other{Mora sadržavati najmanje # posebnih simbola}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Mora sadržavati najmanje 1 znak koji nije slovo}one{Mora sadržavati najmanje # znak koji nije slovo}few{Mora sadržavati najmanje # znaka koja nisu slova}other{Mora sadržavati najmanje # znakova koji nisu slova}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Mora sadržavati najmanje 1 znak koji nije znamenka}one{Mora sadržavati najmanje # znak koji nije znamenka}few{Mora sadržavati najmanje # znaka koja nisu znamenke}other{Mora sadržavati najmanje # znakova koji nisu znamenke}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Administrator uređaja ne dopušta upotrebu nedavne zaporke"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Uzastopno rastući ili padajući slijed brojeva ili ponavljanje brojeva nije dopušteno"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potvrdi"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Izbriši"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zaključavanje zaslona već je promijenjeno. Pokušajte ponovo s novim zaključavanjem zaslona."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Odustani"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Dalje"</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>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktivna aplikacija}one{# aktivna aplikacija}few{# aktivne aplikacije}other{# aktivnih aplikacija}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agenti za pouzdanost"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Za upotrebu prvo postavite zaključavanje zaslona"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Ništa"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktivni agent za pouzdanost}one{# aktivni agent za pouzdanost}few{# aktivna agenta za pouzdanost}other{# aktivnih agenata za pouzdanost}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</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">"Kôd za uparivanje putem Bluetootha"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Unesite kôd za uparivanje pa 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 biste također trebali unijeti ovaj PIN i na drugi uređaj."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Možda ćete ovaj pristupni kôd trebati unijeti i na drugi uređaj."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Potvrdite za uparivanje s koordiniranim skupom"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Dopuštam pristup kontaktima i povijesti poziva"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nije moguće povezati se na <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dostupni uređaji"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Poveži"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Isključi"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Upari i poveži"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Kada je Bluetooth uključen, vaš uređaj može komunicirati s drugim Bluetooth uređajima u blizini."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Kada je Bluetooth uključen, uređaj može komunicirati s ostalim Bluetooth uređajima u blizini.\n\nRadi boljeg doživljaja na uređaju, aplikacije i usluge i dalje mogu tražiti uređaje u blizini u bilo kojem trenutku, čak i kada je Bluetooth isključen. Time se primjerice mogu poboljšati značajke i usluge koje se temelje na lokaciji. To možete promijeniti u postavkama traženja Bluetootha."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Promijeni"</string>
    <string name="device_details_title" msgid="1155622417516195481">"O uređaju"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Postavke tipkovnice"</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_multuple_devices_mac_address" msgid="4974301550897923376">"Bluetooth adresa uređaja:\n<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="remove_association_button" msgid="5004208145998061135">"Ukloni povezivanje"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Prekinuti vezu s aplikacijom?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> više se neće povezivati s vašim uređajem <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Zaboravi uređaj"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Prekini vezu s aplikacijom"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimalan broj povezanih Bluetooth audiouređaja"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Odaberite maksimalan broj povezanih Bluetooth audiouređaja"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Zapisnik o otklanjanju pogrešaka za NFC stog"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Povećaj razinu zapisivanja za NFC stog"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Opširni zapisnik dobavljača o otklanjanju pogrešaka za NFC"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Uključite dodatne zapisnike dobavljača pojedinog uređaja u izvješća o programskim pogreškama koja mogu sadržavati privatne podatke."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Nefiltrirani zapis za NFC NCI"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Snimite detaljne NFC pakete koji možda sadrže privatne informacije."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Ponovo pokrenuti?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Detaljno zapisivanje za NFC namijenjeno je samo u razvojne svrhe. Dodatni podaci NFC-a uključeni su u izvješća o programskim pogreškama koja mogu sadržavati privatne podatke. Ponovo pokrenite uređaj da biste promijenili tu postavku."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Ponovno pokreni"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Emitiranje"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"zrcalo"</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">"U blizini nema uređaja."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Povezivanje"</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">"Nedostupno"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opcije bežičnog prikaza"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Zaboravi"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Naziv"</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_band_6ghz" msgid="8166833829829455339">"6 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">"Istječe <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</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 Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> želi isključiti Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Potvrdi bajtni kôd aplikacija iz kojih se mogu uklanjati pogreš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 pogreške"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Prikaži učestalost osvježavanja"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Prikaži trenutačnu učestalost osvježavanja"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Zahtijevaj otključavanje uređaja za NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Spreman za prijenos sadržaja aplikacija NFC-om"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Isključeno"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nije dostupno jer je NFC isključen"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Kada je ta značajka uključena, sadržaj aplikacije možete prenijeti na drugi uređaj na kojem je omogućen NFC tako da uređaje postavite jedan uz drugi. Na primjer, možete prenositi web-stranice, videozapise s YouTubea, kontakte i još mnogo toga.\n\nUređaje samo postavite jedan uz drugi (prislonite im poleđine) pa dodirnite zaslon. Aplikacija određuje što će se prenijeti."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Koristi Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Postavke Wi-Fija"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Odaberite Wi‑Fi mrežu"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Uključivanje Wi-Fija…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Isključivanje Wi-Fija…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Pogreška"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"U ovoj zemlji nije dostupna frekvencija od 5 GHz"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"U načinu rada u zrakoplovu"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Obavijesti me o javnim mrežama"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Obavještava vas kada je dostupna javna mreža visoke kvalitete"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Automatski uključi Wi-Fi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi‑Fi će se automatski ponovo uključiti u blizini spremljenih mreža visoke kvalitete, poput vaše kućne mreže"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nije dostupno jer je lokacija isključena. Uključite "<annotation id="link">"lokaciju"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instaliraj certifikate"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Da bi se poboljšala točnost lokacije, aplikacije i usluge i dalje mogu tražiti Wi‑Fi mreže u bilo kojem trenutku, čak i kada je Wi‑Fi isključen. Na taj se način mogu, na primjer, poboljšati značajke i usluge koje se temelje na lokaciji. To možete promijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama traženja Wi-Fija<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Da biste poboljšali točnost lokacije, uključite traženje Wi-Fija u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama traženja Wi-Fija<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automatski prijeđi na mobilne podatke"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Koristite mobilne podatke kada Wi-Fi nema pristup internetu. Moguća je naplata potrošnje podatkovnog prometa."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Dodajte mrežu"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Postavke Wi‑Fija"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi se automatski ponovo uključuje"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi se ne uključuje ponovno automatski"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Izravni Wi-Fi"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Da biste vidjeli dostupne mreže, uključite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Traženje mreža…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nemate dopuštenje za promjenu Wi‑Fi mreže."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Uključiti traženje Wi-Fija?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Za automatsko uključivanje Wi‑Fija najprije morate uključiti traženje Wi‑Fija."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Traženje Wi‑Fija omogućuje aplikacijama i uslugama da bilo kada traže Wi‑Fi mreže, čak i kada je Wi‑Fi isključen. Tako se primjerice mogu poboljšati značajke i usluge koje se temelje 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">"Uključeno je traženje Wi‑Fija"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Napredne opcije"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Padajući popis Napredne opcije"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"proširi"</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">"Ako vaš usmjerivač ne emitira ID mreže, ali biste se ubuduće htjeli povezati s njom, mrežu možete postaviti kao skrivenu.\n\nTime bi se mogla ugroziti sigurnost jer će telefon redovito emitirati signal da bi pronašao mrežu.\n\nPostavljanjem mreže kao skrivene neće se promijeniti postavke usmjerivača."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Jačina signala"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Brzina prijenosa"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Brzina primanja"</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">"Spremljeno putem"</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_min_tls_ver" msgid="174023604103299457">"Minimalna verzija TLS-a"</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">"Zaporka"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Prikaži zaporku"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Frekvencija od 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Prednost se daje frekvenciji od 5,0 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Postavke IP-ja"</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">"Pregled ili promjena pretplate"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Nasumično određen 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 donji QR kôd da biste uređaj dodali u 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 u nastavku da biste se povezali s mrežom “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Pridružite se Wi‑Fiju skeniranjem QR koda"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Dijelite Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Skenirajte ovaj QR kôd drugim uređajem da biste se pridružili 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 biste se povezali 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 i dalje imate problema, obratite se proizvođaču uređaja"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Nešto nije u redu"</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 i dalje imate problema, obratite se proizvođaču uređaja"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Na ovom uređaju nije podržano dodavanje \"<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 svojoj Wi‑Fi pristupnoj točki/usmjerivaču"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Provjerite zaporku i pokušajte ponovo"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Obratite se proizvođaču 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">"Odabir mreže"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Da biste povezali uređaj, odaberite mrežu."</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Želite li 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 je podijeljen s uređajem"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Dodaj drugi uređaj"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Odaberite drugu mrežu"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Dodavanje uređaja nije uspjelo"</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 Wi-Fija s ovim uređajem…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Povezivanje…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Dijelite žarišnu točku"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Potvrdite da ste to vi"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Zaporka Wi-Fi mreže: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Zaporka žarišne toč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">"Dopusti povezivanje s ovom mrežom kad je u dometu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Dodajte uređaj"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Dodajte uređaj u ovu mrežu pomoću QR koda"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR kôd nije u važećem formatu"</string>
    <string name="retry" msgid="7542103800274026915">"Ponovi"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Podijeli s drugim 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">"Upotrijebi certifikate sustava"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Nemoj pružiti"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Smatraj pouzdanim prilikom prve upotrebe"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Mreža ima predugačak naziv."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Potrebno je navesti domenu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Potreban je certifikat."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Radi poboljšanja preciznosti lokacije kao i u druge svrhe aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti pregledavanje mreže, čak i kada je Wi-Fi isključen.\n\nŽelite li to dozvoliti za sve aplikacije koje žele izvoditi pregledavanje?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Radi poboljšanja preciznosti lokacije i u druge svrhe nepoznata aplikacija želi uključiti traženje mreža, čak i kad je Wi-Fi isključen.\n\nŽelite li to dopustiti za sve aplikacije koje žele pretraživati?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Dopusti"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Odbij"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Ta mreža nema pristup internetu. Želite li ostati povezani?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Neke aplikacije i usluge možda neće raditi zbog ograničene povezivosti. Želite ostati na toj mreži?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Više ne pitaj za tu mrežu"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi-Fi mreža nije povezana s internetom"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"U slučaju loše veze s Wi-Fi mrežom, uvijek možete prijeći na mobilnu mrežu. Mogu se naplatiti naknade za podatkovni promet."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Prelazak na mobilnu mrežu"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Ostani na Wi‑Fi-ju"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Nemoj više prikazivati"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Poveži"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi uključen"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Povezano s <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 s mrežom 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">"Spremi"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Spremanje mreže nije uspjelo"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Odustani"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Zaboraviti mrežu?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 mreža}one{# mreža}few{# mreže}other{# mreža}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 pretplata}one{# pretplata}few{# pretplate}other{# pretplata}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 mreža i pretplata}one{# mreža i pretplata}few{# mreže i pretplate}other{# mreža i pretplata}}"</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čna MAC adresa (posljednje upotrijebljena)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Podaci o mreži"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podmreže"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Vrsta"</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">"Spremljene mreže"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Pretplate"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Ostale mreže"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Upišite važeću IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Upišite važeću adresu pristupnika."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Upišite važeću DNS adresu."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Upišite prefiks mreže duljine između 0 i 32 znaka."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (ako ga ne nadjača privatni DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (ako ga ne nadjača privatni DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Pristupnik"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Duljina mrežnog prefiksa"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Izravni Wi-Fi"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Traženje uređaja"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Traženje..."</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Promjena naziva uređaja"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Paralelni 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 bilo moguće."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Preimenovanje uređaja nije uspjelo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Isključiti?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Ako odspojite, prekinut će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Ako odspojite, prekinut će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g> i <xliff:g id="PEER_COUNT">%2$s</xliff:g> te ostalim uređajima."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Otkazati pozivnicu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Želite li otkazati pozivnicu za povezivanje s korisnikom <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Zaboraviti ovu grupu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wi‑Fi žarišna točka"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internetska veza i sadržaj ne dijele se s drugim uređajima"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Zaporka nije postavljena"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Naziv žarišne točke"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Zaporka žarišne točke"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Frekvencija pristupne točke"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Automatski isključi žarišnu točku"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kada nema povezanih uređaja"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Proširi kompatibilnost"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Pomaže drugim uređajima da pronađu ovu žarišnu točku. Smanjuje brzinu povezivanja sa žarišnom točkom."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Pomaže drugim uređajima da pronađu ovu žarišnu točku. Povećava potrošnju baterije."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Brzina i kompatibilnost"</string>
    <!-- no translation found for wifi_hotspot_speed_summary_2g (5063438001736234858) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_summary_5g (6221158936983135040) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_summary_6g (8863992901226595544) -->
    <skip />
    <!-- no translation found for wifi_hotspot_speed_summary_2g_and_5g (5931052946168943750) -->
    <skip />
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Odaberite frekvenciju za svoju žarišnu točku. Frekvencija utječe na brzinu veze i na to koje vrste uređaja mogu pronaći vašu žarišnu točku."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Preferirana frekvencija"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <!-- no translation found for wifi_hotspot_speed_2g_summary (6930273933810520155) -->
    <skip />
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <!-- no translation found for wifi_hotspot_speed_5g_summary (562987935924535694) -->
    <skip />
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 i 5 GHz"</string>
    <!-- no translation found for wifi_hotspot_speed_2g_5g_summary (8104575293617700173) -->
    <skip />
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <!-- no translation found for wifi_hotspot_speed_6g_summary (8675262219242174548) -->
    <skip />
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nije dostupno u vašoj državi ili regiji"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Ako vaša preferirana frekvencija nije dostupna, vaša žarišna točka može upotrebljavati neku drugu. Postavke sigurnosti žarišne točke mogu se promijeniti ako promijenite frekvenciju."</string>
    <!-- no translation found for wifi_hotspot_security_summary_unavailable (117582979310345853) -->
    <skip />
    <!-- no translation found for wifi_hotspot_security_footer (4608329688744949796) -->
    <skip />
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Uključivanje žarišne točke…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Isključivanje žarišne točke…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Modemsko povezivanje nije dostupno"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Više informacija zatražite od svog mobilnog operatera."</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivan"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Spremiti ovu mrežu?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Spremanje…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Spremljeno"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Spremanje nije moguće. Pokušajte ponovo."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Spremiti mreže?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Spremanje <xliff:g id="NUMBER">%d</xliff:g> mreža…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Mreže su spremljene"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Wi-Fi pozivi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Proširite pozive putem Wi‑Fi-ja"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Uključite Wi-Fi pozive da biste proširili pokrivenost"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Postavka poziva"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Postavka poziva"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Željena postavka za roaming"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Željena postavka za roaming"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobilni uređaj"</item>
    <item msgid="3027927219952052398">"Samo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mobilni uređaj"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Ako Wi‑Fi nije dostupan, koristi mobilnu mrežu"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Ako mobilna mreža nije dostupna, koristi Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Pozivi putem Wi-Fija. Ako se Wi‑Fi izgubi, poziv će završiti."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kada su Wi-Fi pozivi uključeni, telefon može usmjeravati pozive putem Wi-Fi mreža ili mreže vašeg mobilnog operatera, ovisno o vašoj želji i o tome koji je signal jači. Prije nego što uključite tu značajku, raspitajte se o naknadi i ostalim pojedinostima kod mobilnog operatera.<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="8102786488994263815">"Adresa za hitne slučajeve"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Upotrebljava se kao vaša lokacija kada upućujete hitne pozive putem Wi‑Fi-ja"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Saznajte više"</annotation>" o značajkama privatnog DNS-a"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Uključeno"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivirajte Wi-Fi pozive"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Uključite Wi-Fi pozive"</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="sound_settings" msgid="7622986039384531304">"Zvuk i vibracija"</string>
    <string name="account_settings" msgid="255404935489127404">"Računi"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Računi radnih profila – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Računi osobnih profila"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Radni račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Osobni račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Pretražite"</string>
    <string name="display_settings" msgid="7197750639709493852">"Zaslon"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automatsko zakretanje zaslona"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Isključeno"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Uključeno"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Uključeno – na temelju lica"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Prepoznavanje lica"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Saznajte više o automatskom zakretanju"</string>
    <string name="auto_rotate_summary_a11y" msgid="1505094100328581685">"Kad izmjenjujete prikaz zaslona između okomitog i vodoravnog"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Razlučivost zaslona"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Visoka razlučivost"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Puna razlučivost"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Puna razlučivost više troši bateriju. Promjena razlučivosti može uzrokovati ponovno pokretanje nekih aplikacija."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Odabrano"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Boje"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Prirodno"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Pojačano"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Zasićeno"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Prilagodljivo"</string>
    <string name="brightness" msgid="6216871641021779698">"Jačina svjetline"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Prilagodljiva svjetlina"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Svjetlina zaslona automatski će se prilagoditi vašoj okolini i aktivnostima. Klizač možete pomicati ručno kako bi prilagodljiva svjetlina dobila podatke o tome što vam odgovara."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Uključeno"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Isključeno"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Prikaz balansa bijele boje"</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="3627278682437562787">"Automatski povećava učestalost osvježavanja sa 60 na <xliff:g id="ID_1">%1$s</xliff:g> Hz za dio sadržaja. Povećava potrošnju baterije."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Prisilna maksimalna učestalost osvježavanja"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Najviša učestalost osvježavanja za poboljšano reagiranje na dodir i kvalitetu animacije. Povećava potrošnju baterije."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Pozornost na zaslonu"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Potreban je pristup kameri"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Za pozornost na zaslonu potreban je pristup kameri. Dodirnite da biste upravljali dopuštenjima za usluge personaliziranja uređaja"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Upravljajte dopuštenjima"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Sprječava isključivanje zaslona ako gledate u njega"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Značajka Pozornost na zaslonu pomoću prednje kamere otkriva gleda li osoba u zaslon. Funkcionira na uređaju i slike se nikad ne pohranjuju i ne šalju Googleu."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Uključivanje pozornosti na zaslonu"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Zaslon ostaje uključen sve dok ga gledate"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Fotoaparat je zaključan"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Fotoaparat mora biti otključan za prepoznavanje lica"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kamera mora biti otključana da bi pozornost na zaslonu funkcionirala"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Za prepoznavanje lica potreban je pristup fotoaparatu. Dodirnite da biste upravljali dopuštenjima za usluge personaliziranja uređaja"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Upravljanje dopuštenjima"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Noćno svjetlo"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Noćno svjetlo boji zaslon uređaja u jantarnu nijansu. To olakšava gledanje zaslona i čitanje pri slabom svjetlu i može vam pomoći da lakše zaspite."</string>
    <string name="night_display_auto_mode_title" msgid="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či u prilagođeno vrijeme"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Od zalaska do izlaska sunca"</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_temperature_title" msgid="857248782470764263">"Intenzitet"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nikad se ne uključuje automatski"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Uključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Uključuje se automatski kad zađe sunce"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nikad se ne isključuje automatski"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Isključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Isključuje se automatski kad sunce izađe"</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">"Lokacija uređaja potrebna je da bi se odredilo vrijeme zalaska i izlaska sunca."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Postavke lokacije"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Odmah uključi"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Odmah isključi"</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">"Tamni način rada"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Raspored"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nijedan"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Od zalaska do izlaska sunca"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Uključi u prilagođeno vrijeme"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Uključuje se za vrijeme spavanja"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nikad se ne uključuje automatski"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Uključuje se automatski kad zađe sunce"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Uključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Uključit će se automatski u vrijeme spavanja"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nikad se ne isključuje automatski"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Isključuje se automatski kad sunce izađe"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Isključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Isključit će se automatski u vrijeme spavanja"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tamna tema upotrebljava crnu pozadinu radi produljenja trajanja baterije na nekim zaslonima. Rasporedi s tamnom temom čekaju s uključivanjem dok se zaslon ne isključi."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tamna tema trenutačno prati raspored načina rada za spavanje"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Postavke načina rada za spavanje"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Automatsko isključivanje zaslona"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Nakon <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nije postavljeno"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Pozadinska slika"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Pozadina i stil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Početni zaslon, zaključan zaslon"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Promijenite pozadinsku sliku"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Prilagodite zaslon"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Odabir pozadinske slike iz"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Prilagodba telefona"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Isprobajte različite stilove, pozadine i drugo"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Čuvar zaslona"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"čuvar zaslona"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nije dostupno jer je uključen način rada u vrijeme spavanja"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Koristi čuvar zaslona"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Tijekom punjenja ili kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Na priklj. stanici tijekom punjenja"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Tijekom 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_on" msgid="4210827304351483645">"Uključeno/<xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Isključeno"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kada pokrenuti"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Aktivacija podizanjem"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambijentalni zaslon"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kada prikazati"</string>
    <string name="doze_title" msgid="1523090408230862316">"Aktiviraj zaslon za obavijesti"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kada je zaslon taman, uključit će se u slučaju novih obavijesti"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Uvijek prikaži vrijeme i podatke"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Povećana potrošnja baterije"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Podebljani tekst"</string>
    <string name="title_font_size" msgid="570613010306330622">"Veličina fonta"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Povećajte ili smanjite tekst"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Postavke zaključavanja SIM-a"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Zaključavanje SIM-a"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Zaključajte SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Promijeni PIN za SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM PIN"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Zaključajte SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Otključajte SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Stari PIN SIM kartice"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Novi SIM PIN"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Ponovo unesite novi PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN SIM kartice"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Unesite PIN koji ima od 4 do 8 brojeva"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN-ovi se ne podudaraju"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Uspješno je promijenjen PIN SIM-a"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Onemogućivanje PIN-a nije uspjelo."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Omogućivanje PIN-a nije uspjelo."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"U redu"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Odustani"</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 usluge mobilnog operatera <xliff:g id="CARRIER2_0">%2$s</xliff:g> za mobilne podatke. Ako prijeđete na mobilnog operatera <xliff:g id="CARRIER1">%1$s</xliff:g>, operater<xliff:g id="CARRIER2_1">%2$s</xliff:g> više se neće koristiti za mobilne podatke."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Koristi operatera <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Želite li ažurirati željeni SIM?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jedini SIM u vašem uređaju. Želite li upotrebljavati taj SIM za mobilne podatke, pozive i SMS poruke?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Poboljšati pokrivenost mob. podacima?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Omogućite uređaju da se automatski prebaci na mobilnog operatera <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> za mobilne podatke u slučaju bolje dostupnosti."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Vašoj organizaciji mogu biti vidljivi pozivi, poruke i mrežni promet."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Netočan PIN kôd SIM kartice; sada morate kontaktirati svog mobilnog operatera da bi otključao vaš uređaj."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{PIN kôd SIM-a nije točan. Imate još # pokušaj, a zatim ćete morati kontaktirati mobilnog operatera da bi otključao uređaj.}one{PIN kôd SIM-a nije točan. Imate još # pokušaj.}few{PIN kôd SIM-a nije točan. Imate još # pokušaja.}other{PIN kôd SIM-a nije točan. Imate još # pokušaja.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Netočan PIN kôd SIM kartice; imate još jedan pokušaj prije nego što budete morali kontaktirati svog mobilnog operatera da bi otključao vaš uređaj."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operacija PIN-a SIM kartice nije uspjela!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Ažuriranja sustava"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Verzija sustava Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Sigurnosno ažuriranje za Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</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">"Osnovna verzija"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Verzija jezgre"</string>
    <string name="build_number" msgid="9009733242117579826">"Broj međuverzije"</string>
    <string name="module_version" msgid="1787518340082046658">"Ažuriranje sustava s Google Playa"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nije dostupno"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Pohrana"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Pohrana i predmemorija"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Postavke pohrane"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (utor za SIM <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (utor za SIM <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (utor za SIM <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primarno)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Da biste je vidjeli, odaberite spremljenu mrež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">"PRL verzija"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (utor za SIM <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (utor za SIM <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primarno)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Uključeno"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Isključeno"</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 mobilne podatkovne mreže"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Vrsta mobilne govorne mreže"</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">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Mreža"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"MAC adresa Wi-Fija"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"MAC adresa uređaja za Wi-Fi"</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="memory_calculating_size" msgid="3898240439798661242">"Izračun u tijeku..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Preimenuj"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Učitaj"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Izbaci"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatiranje SD kartice za prijenosnu pohranu"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatiraj karticu"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatiraj kao prijenosnu"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatiraj"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Premjesti podatke"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Zaboravi"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Postavi"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Oslobađanje prostora"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Upravljajte pohranom"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Oslobađanje prostora"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Otvorite aplikaciju Files da biste oslobodili prostor i upravljali njime"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Drugi korisnici"</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_mount_success" msgid="393972242641313135">"Učitano: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Učitavanje nije uspjelo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Sigurno izbacivanje uspjelo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Sigurno izbacivanje nije uspjelo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Promjena naziva pohrane"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Medij za pohranu <xliff:g id="NAME_0">^1</xliff:g> oštećen je. \n\nZa upotrebu medija <xliff:g id="NAME_1">^1</xliff:g> prvo ga trebate postaviti."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Možete formatirati ovu SD karticu kako biste pohranili fotografije, videozapise, glazbu i druge sadržaje te im pristupili na drugim uređajima. \n\n"<b>"Svi će se podaci na SD kartici izbrisati."</b>" \n\n"<b>"Prije formatiranja"</b>" \n\n"<b>"Izradite sigurnosnu kopiju fotografija i drugog medijskog sadržaja"</b>" \nPremjestite medijske datoteke u neku drugu pohranu na ovom uređaju ili na računalo pomoću USB kabela. \n\n"<b>"Sigurnosno kopirajte aplikacije"</b>" \nSve će se aplikacije pohranjene na mediju <xliff:g id="NAME">^1</xliff:g> deinstalirati i njihovi će se podaci izbrisati. Da biste zadržali aplikacije, premjestite ih u neku drugu pohranu na ovom uređaju."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Kada izbacite uređaj <xliff:g id="NAME_0">^1</xliff:g>, aplikacije koje su pohranjene na njemu prestat će funkcionirati, a medijske datoteke pohranjene na njemu neće biti dostupne dok ga ponovo ne umetnete."</b>" \n\nUređaj <xliff:g id="NAME_1">^1</xliff:g> formatiran je tako da funkcionira samo na ovom uređaju. Neće funkcionirati na drugim uređajima."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Da biste pristupili aplikacijama, fotografijama ili podacima koje sadrži uređaj <xliff:g id="NAME">^1</xliff:g>, umetnite ga ponovo. \n\nMožete i zaboraviti tu pohranu ako uređaj nije dostupan. \n\nAko se odlučite za opciju zaborava, svi podaci koje uređaj sadrži zauvijek će se izgubiti. \n\nKasnije možete ponovo instalirati aplikacije, ali će njihovi podaci pohranjeni na tom uređaju biti izgubljeni."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Zaboraviti medij za pohranu <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Sve aplikacije, fotografije i podaci pohranjeni na SD kartici <xliff:g id="NAME">^1</xliff:g> trajno će se izbrisati."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sustav obuhvaća datoteke koje se upotrebljavaju za pokretanje Androida verzije <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Koris. u nač. rada za goste ne mogu form. SD kart."</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatira se <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Ne uklanjajte medij <xliff:g id="NAME">^1</xliff:g> dok se formatira."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"Formatiran medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Premjestite aplikaciju <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Premještanje aplikacije <xliff:g id="APP">^1</xliff:g> i njezinih podataka na uređaj <xliff:g id="NAME_0">^2</xliff:g> trajat će samo nekoliko trenutaka. Nećete moći upotrebljavati tu aplikaciju dok premještanje ne završi. \n\nNe uklanjajte uređaj <xliff:g id="NAME_1">^2</xliff:g> tijekom premještanja."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Da biste premjestili podatke, morate otključati korisnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Premještanje aplikacije <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Ne uklanjajte uređaj <xliff:g id="NAME">^1</xliff:g> tijekom premještanja. \n\nAplikacija <xliff:g id="APP">^2</xliff:g> na ovom uređaju neće biti dostupna dok premještanje ne završi."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Za što će se upotrebljavati <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Ili"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatiranje SD kartice za prijenosnu pohranu"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Pohranite fotografije, videozapise, glazbu i druge sadržaje i pristupajte im s drugih uređaja. &lt;a href=https://support.google.com/android/answer/12153449&gt;Saznajte više o postavljanju SD kartice&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatiraj"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Postavi kasnije"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formatirati medij <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"<xliff:g id="NAME_0">^1</xliff:g> mora se formatirati radi spremanja aplikacija, datoteka i medijskog sadržaja. \n\nFormatiranjem će se izbrisati sav postojeći sadržaj na mediju <xliff:g id="NAME_1">^2</xliff:g>. Sigurnosno kopirajte sadržaj na drugi medij <xliff:g id="NAME_2">^3</xliff:g> ili uređaj kako ga ne biste izgubili."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Medij <xliff:g id="NAME_0">^1</xliff:g> mora se formatirati kako bi se na njemu mogle pohraniti fotografije, videozapisi, glazba i drugi sadržaji. \n\nFormatiranjem će se izbrisati postojeći sadržaj na mediju <xliff:g id="NAME_1">^2</xliff:g>. Sigurnosno kopirajte sadržaj na drugi medij <xliff:g id="NAME_2">^3</xliff:g> ili uređaj kako ga ne biste izgubili."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatiraj medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Premjestiti sadržaj na medij <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Tijekom premještanja:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ne uklanjajte medij <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Neke aplikacije neće funkcionirati."</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">"Medij <xliff:g id="NAME">^1</xliff:g> spor je"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Medij <xliff:g id="NAME_0">^1</xliff:g> možete i dalje upotrebljavati, ali će možda biti spor. \n\nAplikacije pohranjene na mediju <xliff:g id="NAME_1">^2</xliff:g> možda neće pravilno funkcionirati, a prijenos sadržaja može trajati dugo. \n\nPokušajte upotrijebiti brži medij <xliff:g id="NAME_2">^3</xliff:g> ili upotrebljavajte ovaj medij <xliff:g id="NAME_3">^4</xliff:g> za prijenosnu pohranu."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="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="7688457485389886923">"Možete početi upotrebljavati medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Možete početi upotrebljavati medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Možete početi upotrebljavati medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Status baterije"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Razina baterije"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Zajedničko"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Zajedničke postavke"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN-ovi"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Uređivanje pristupne točke"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nije postavljeno"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"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">"Proxy"</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">"Zaporka"</string>
    <string name="apn_server" msgid="6997704279138388384">"Poslužitelj"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS proxy"</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_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 roaming"</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">"Nositelj"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Vrsta MVNO-a"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Vrijednost MVNO-a"</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">"Spremi"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Odustani"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Polje naziva ne može biti prazno."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN ne može biti prazan."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC polje mora imati 3 znamenke."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Polje MNC mora imati 2 ili 3 znamenke."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Mobilni operater ne dopušta dodavanje APN-ova vrste %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Vraćanje zadanih APN postavki"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Vrati na zadano"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Poništavanje zadanih postavki APN-a dovršeno."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Poništavanje opcija"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Poništi postavke mobilne mreže"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Poništit će se sve postavke mobilne mreže"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Poništiti postavke mob. mreže?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Poništi Bluetooth i Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Poništit će se sve postavke Wi‑Fija i Bluetootha. Ta se radnja ne može poništiti."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Poništi"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth i Wi‑Fi su poništeni"</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Izbriši"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Izbriši eSIM-ove"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Time se neće poništiti ugovori o mobilnim uslugama. Za preuzimanje zamjenskih SIM-ova obratite se mobilnom operateru."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Poništi postavke"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Želite li poništiti sve postavke mreže? Ta se radnja ne može poništiti."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Želite li vratiti sve postavke mreže na zadano i izbrisati eSIM-ove? Ta se radnja ne može poništiti."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Poništi postavke"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Poništiti?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Vraćanje mreže na zadano 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">"Brisanje SIM-ova nije uspjelo"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"eSIM-ovi se ne mogu izbrisati zbog pogreške.\n\nPonovo pokrenite uređaj i pokušajte još jednom."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Brisanje svih podataka (vraćanje na tvorničke postavke)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Izbriši sve podatke"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"glazbu"</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"Time se neće otkazati vaš ugovor o mobilnoj usluzi."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Izbrisat će se svi vaši osobni podaci i preuzete aplikacije. Ta se radnja ne može poništiti."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Izbrisat će se svi vaši osobni podaci, uključujući preuzete aplikacije i SIM-ove. Ta se radnja ne može poništiti."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Želite li izbrisati sve podatke?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Vraćanje na tvorničko stanje 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, preusmjeravanje poziva, ID pozivatelja"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB dijeljenje veze"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Prijen. pristupna točka"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Dijeljenje Bluetoothom veze"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Dijeljenje veze"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Žarišna točka i modemsko povezivanje"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Žarišna točka uključena, modemsko povezivanje"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Žarišna točka uključena"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Modemsko povezivanje"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Dok je Štednja podatkovnog prometa uključena, ne možete upotrebljavati modemsko povezivanje ni prijenosne žarišne točke"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Samo žarišna toč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">"Žarišna točka, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Žarišna točka, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Žarišna toč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">"Žarišna točka, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Žarišna točka, USB, ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Žarišna toč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">"Žarišna točka, USB, Bluetooth, ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internetska veza ne dijeli se s drugim uređajima"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Isključeno"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Modemsko povezivanje"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Nemoj koristiti Wi‑Fi žarišnu točku"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Dijeli internet samo putem USB-a"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Dijeli internet samo putem Bluetootha"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Dijeli internet samo ethernetom"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Dijeli internet samo putem USB-a i Bluetootha"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Dijeli internet samo USB-om i Bluetoothom"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Dijeli internet samo Bluetoothom i ethernetom"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Dijeli internet samo USB-om, Bluetoothom i ehernetom"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Dijeljenje veze USB-om"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Dijeljenje veze Bluetoothom"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Dijeljenje veze ethernetom"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Pomoću žarišne točke i modemskog povezivanja drugi se uređaji mogu povezati s internetom putem podatkovne veze vašeg mobilnog uređaja. Žarišnu točku mogu izraditi i aplikacije radi dijeljenja sadržaja s uređajima u blizini."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Pomoću žarišne točke i modemskog povezivanja drugi se uređaji mogu povezati s internetom putem vašeg Wi-Fija ili podatkovne veze vašeg mobilnog uređaja. Žarišnu točku mogu izraditi i aplikacije radi dijeljenja sadržaja s uređajima u blizini."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pomoć"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilna mreža"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobilni paket"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS aplikacija"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Želite li promijeniti aplikaciju za SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Želite li upotrijebiti aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> kao svoju aplikaciju za SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Želite li upotrijebiti aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> kao svoju aplikaciju za SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Želite li zamijeniti Wi‑Fi assistanta?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Želite li upotrebljavati aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g>, a ne <xliff:g id="CURRENT_APP">%2$s</xliff:g>, za upravljanje mrežnim vezama?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Želite li upotrebljavati aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Nepoznati operater SIM kartice"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> nema poznatu web-lokaciju za pružanje niza usluga"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Umetnite SIM karticu i pokrenite ponovo"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Povežite se s internetom"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavni zahtjevi za lokaciju"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za poslovni profil"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Dopuštenja lokacije za aplikacije"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokacija je isključena"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# od {total} aplikacije ima pristup lokaciji}one{# od {total} aplikacije imaju pristup lokaciji}few{# od {total} aplikacije imaju pristup lokaciji}other{# od {total} aplikacija imaju pristup lokaciji}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Nedavni pristup"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Pogledajte sve"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Prikaži pojedinosti"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Nijedna aplikacija nije nedavno zatražila lokaciju"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Nijedna aplikacija nije pristupila lokaciji u posljednje vrijeme"</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_wifi_always_scanning_title" msgid="5004781272733434794">"Traženje Wi‑Fija"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Dopustite aplikacijama i uslugama da traže Wi‑Fi mreže u bilo kojem trenutku, čak i kada je Wi‑Fi isključen. Time se primjerice mogu poboljšati značajke i usluge koje se temelje na lokaciji."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Traženje Bluetootha"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Dopustite aplikacijama i uslugama da traže uređaje u blizini u bilo kojem trenutku, čak i kada je Bluetooth isključen. Time se primjerice mogu poboljšati značajke i usluge koje se temelje na lokaciji."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Usluge lokacije"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Usluge lokacije"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Koristi lokaciju"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Nije moguće automatski postaviti vremensku zonu"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Isključeni su lokacija ili usluge lokacije"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Potrebna je lokacija uređaja"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Da biste postavili vremensku zonu na temelju svoje lokacije, uključite lokaciju, a zatim ažurirajte postavke vremenske zone"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Postavke lokacije"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Popravi"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Odustani"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatska vremenska zona je isključena"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Onemogućeno je otkrivanje vremenske zone lokacije"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Nije podržano otkrivanje vremenske zone lokacije"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Izmjene značajke otkrivanja vremenske zone lokacije nisu dopuštene"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Lokacija se može koristiti za postavljanje vremenske zone"</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="manual" msgid="3651593989906084868">"Priručnik"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulatorne oznake"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Priručnik o sigurnosti i zakonskim propisima"</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 sustava s Google Playa"</string>
    <string name="terms_title" msgid="2071742973672326073">"Uvjeti i odredbe"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"WebView licenca sustava"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Zasluge za pozadine"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Davatelji satelitskih slika:\n©2014. CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Priručnik"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Došlo je do problema prilikom učitavanja priručnika."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licence trećih strana"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Došlo je do problema s učitavanjem licenci."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Učitavanje…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Učitavanje…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Postavite zaporku"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Postavite zaporku poslovnog profila"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Postavite PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Postavite PIN poslovnog profila"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Postavite uzorak"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Za dodatnu sigurnost postavite uzorak za otključavanje uređaja"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Postavite uzorak poslovnog profila"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Otisak prsta zahtijeva zaporku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Otisak prsta zahtijeva uzorak"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Radi sigurnosti postavite PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Otisak prsta zahtijeva PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Ponovno unesite zaporku"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Ponovo unesite zaporku poslovnog profila"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Unesite poslovnu zaporku"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potvrda uzorka"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Unesite poslovni uzorak"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Ponovno unesite PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Ponovo unesite PIN poslovnog profila"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Unos poslovnog PIN-a"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Zaporke 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 iscrtajte obrazac"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Odabir načina otključavanja"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Zaporka 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="622276003801157839">"Otključavanje licem zahtijeva zaporku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Otključavanje licem zahtijeva uzorak"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Otključavanje licem zahtijeva PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Postavite zaporku za upotrebu lica ili otiska prsta"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Postavite uzorak za upotrebu lica ili otiska prsta"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Postavite PIN za upotrebu lica ili otiska prsta"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Zaboravili ste zaporku?"</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 biste nastavili"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Unesite PIN uređaja da biste nastavili"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Unesite zaporku uređaja da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Unesite uzorak radnog profila da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Unesite poslovni PIN da biste nastavili"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Unesite zaporku radnog profila da biste nastavili"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Za dodatnu sigurnost upotrijebite 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 zaporku uređaja"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Za dodatnu sigurnost upotrijebite uzorak radnog profila"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Za dodatnu sigurnost unesite PIN radnog profila"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Za dodatnu sigurnost unesite zaporku radnog profila"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Potvrdite uzorak"</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 zaporku"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Potvrđivanje identiteta"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Da biste prenijeli Google račune, postavke i drugo, unesite uzorak drugog uređaja. Uzorak šifriran."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Da biste prenijeli Google račune, postavke i drugo, unesite PIN drugog uređaja. PIN je šifriran."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Da biste prenijeli Google račune, postavke i drugo, unesite zaporku drugog uređaja. Zaporka šifrirana."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Koristite i uzorak za otključavanje uređaja"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Koristite i PIN za otključavanje uređaja"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Koristite i zaporke za otključavanje uređaja"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Pogrešan PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Pogrešna zaporka"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Pogrešan uzorak"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Hitni slučaj"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Sigurnost uređaja"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Izmijeni 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">"Iscrtajte uzorak za otključavanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Pritisnite Izbornik za pomoć."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Dignite prst kad završite"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Povežite barem <xliff:g id="NUMBER">%d</xliff:g> točke. Pokušajte ponovo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Uzorak je zabilježen"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Ponovno iscrtajte uzorak za potvrdu"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Vaš novi uzorak za otključavanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potvrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Iscrtajte ponovno"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Izbriš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">"Potreban je uzorak"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Morate iscrtati uzorak za otključavanje zaslona"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Učini uzorak vidljivim"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Poboljšana privatnost PIN-a"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Onemogući animacije tijekom unosa PIN-a"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Učini uzorak profila vidljivim"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibracija prilikom dodira"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Gumb za uklj. zaključava telefon"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Osim kad ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> drži otključanim"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Postavi uzorak za otključavanje"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Izmijeni uzorak za otključavanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kako iscrtati uzorak za otključavanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Previše netočnih pokušaja. Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikacija nije instalirana na vašem telefonu."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Sigurnost poslovnog profila"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zaključavanje zaslona na poslovnom profilu"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Isti način zaključavanja"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Poslovni profil i zaslon uređaja zaključavaju se na isti način"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Želite li upotrijebiti jedno zaključavanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Uređaj će upotrebljavati zaključavanje zaslona za poslovni profil. Na oba će se zaključavanja primjenjivati pravila za poslovni profil."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Zaključavanje vašeg poslovnog profila ne udovoljava sigurnosnim zahtjevima vaše organizacije. Možete upotrebljavati isto zaključavanje zaslona za uređaj i poslovni profil, no primjenjivat će se pravila zaključavanja zaslona za poslovni profil."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Isti način zaključavanja"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Isti način zaključavanja"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Isto kao i zaključavanje zaslona na uređaju"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Upravljanje aplikacijama"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informacije o aplikaciji"</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 otvorene aplikacije"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Pogledajte sve aplikacije}one{Pregledajte svu # aplikaciju}few{Pregledajte sve # aplikacije}other{Pregledajte svih # aplikacija}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Obratite se IT administratoru"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Može vam pomoći s poništavanjem PIN-a, uzorka ili zaporke"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Napredne postavke"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Omogućiti 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">"Otvori prema zadanim postavkama"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Zadane postavke"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilnost zaslona"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Dopuštenja"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Predmemorija"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Isprazni predmemoriju"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Predmemorija"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 stavka}one{# stavka}few{# stavke}other{# stavki}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Izbriši pristup"</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">"USB aplikacija za pohranu"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Podaci korisnika"</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">"Isprazni pohranu"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Deinstaliraj ažuriranja"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Dopusti ograničene postavke"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Neke aktivnosti koje ste odabrali otvaraju se u ovoj aplikaciji prema zadanim postavkama."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Odlučili ste dopustiti ovoj aplikaciji izradu widgeta i pristupanje njihovim podacima."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nema zadanih postavki."</string>
    <string name="clear_activities" msgid="488089228657585700">"Izbriši zadane postavke"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Ta aplikacija možda nije dizajnirana za vaš zaslon. Ovdje možete provjeriti kako se prilagođava vašem zaslonu."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Pitaj pri pokretanju"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skaliranje aplikacije"</string>
    <string name="unknown" msgid="8192160131923461175">"Nepoznato"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Poredaj prema nazivu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Poredaj po veličini"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Najnovije"</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 predmemorije"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikacija za hitne slučajeve"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Poništavanje postavki aplikacija"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Poništiti postavke aplikacija?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Sve sljedeće postavke vratit će se na zadano:\n\n"<li>"onemogućene aplikacije"</li>\n<li>"onemogućene obavijesti aplikacija"</li>\n<li>"zadane aplikacije za radnje"</li>\n<li>"ograničenja pozadinskih podataka za aplikacije"</li>\n<li>"sva ograničenja dopuštenja"</li>\n<li>"postavke potrošnje baterije."</li>\n\n"Nećete izgubiti podatke aplikacija."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Poništi aplikacije"</string>
    <string name="filter" msgid="9039576690686251462">"Filtar"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Odabir opcije filtra"</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">"Pokrenuto"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nije instalirano za korisnika"</string>
    <string name="installed" msgid="2837449358488825884">"Instalirano"</string>
    <string name="no_applications" msgid="985069304755391640">"Nema aplikacija."</string>
    <string name="internal_storage" msgid="999496851424448809">"Unutarnja pohrana"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Ponovni izračun veličine…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Želite li izbrisati podatke aplikacije?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Podaci ove aplikacije, uključujući datoteke i postavke, trajno će se izbrisati s ovog uređaja"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"U redu"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Odustani"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Izbriši"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikacija nije pronađena na popisu instaliranih aplikacija."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Brisanje pohrane za aplikaciju nije uspjelo."</string>
    <string name="computing_size" msgid="4915310659841174866">"Izračunavanje..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nije 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="another_migration_already_in_progress" msgid="6550546307856052261">"U tijeku je neko drugo premještanje."</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 instalacije nije važeća."</string>
    <string name="system_package" msgid="7559476279008519360">"Ažuriranja sustava nije moguće instalirati na vanjskom mediju."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Administrator uređaja ne može se 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 silom zaustavite aplikaciju, možda će se ponašati nepredviđeno."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Onemogući aplikaciju"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ako onemogućite tu aplikaciju, Android i druge aplikacije možda više neće funkcionirati pravilno. Napominjemo da ne možete izbrisati tu aplikaciju jer je predinstalirana na vašem uređaju. Ako je onemogućite, isključit ćete je i više se neće prikazivati na vašem uređaju."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Trgovina"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Pojedinosti o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikacija instalirana iz: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Više informacija o aplikaciji <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"U tijeku"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nikada nije upotrebljavano)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Upotreba pohrane"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Ponovno pokretanje"</string>
    <string name="cached" msgid="5379485147573438201">"Pozadinski proces u predmemoriji"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Ništa se ne izvodi."</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">"<xliff:g id="MEMORY">%1$s</xliff:g> slobodno"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> up."</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">"Uklonjeni 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> usluga"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"Broj procesa: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, broj usluga: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesa i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memorija uređaja"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Upotreba RAM-a za aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sustav"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Dostupno"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Iskorišteno"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"U predmemoriji"</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 je uslugu pokrenula njezina aplikacija. Zaustavljanje može uzrokovati pad aplikacije."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Ova se aplikacija ne može sigurno zaustaviti. Ako je zaustavite, mogli biste izgubiti trenutačan rad."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Ovo je proces stare aplikacije koja se još uvijek izvršava u slučaju da opet bude potrebna. Obično je nema potrebe zaustavljati."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutačno u upotrebi. Dodirnite Postavke da biste upravljali."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Glavni proces u upotrebi."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Usluga <xliff:g id="COMP_NAME">%1$s</xliff:g> u upotrebi je."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Pružatelj <xliff:g id="COMP_NAME">%1$s</xliff:g> u upotrebi je."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Zaustaviti sistemsku uslugu?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Jezici, unos i pokreti"</string>
    <string name="language_settings" msgid="8700174277543875046">"Jezici i unos"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Jezici"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tipkovnica"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nemate dopuštenje 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">"Tipkovnica i načini unosa"</string>
    <string name="system_language" msgid="1146762166579643257">"Jezici sustava"</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">"Autom. veliko poč. sl."</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Postavi veliko slovo na početku rečenice"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatsko stavljanje interpunkcije"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Postavke fizičke tipkovnice"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Pritisnite razmaknicu dvaput za umetanje \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Prikaži zaporke"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Nakratko prikaži znakove tijekom unosa"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Ovaj alat za provjeru pravopisa može prikupljati sav tekst koji upisujete, uključujući osobne podatke kao što su zaporke i brojevi kreditnih kartica. Dolazi s aplikacije <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Upotrebljavati taj alat za provjeru pravopisa?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Postavke"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jezik"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tipkovnice"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Tipkovnica na zaslonu"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Dostupna tipkovnica na zaslonu"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Upravljajte tipkovnicama na zaslonu"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opcije"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fizička tipkovnica"</string>
    <string name="show_ime" msgid="4334255501724746849">"Upotreba tipkovnice na zaslonu"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Zadrži na zaslonu dok je fizička tipkovnica aktivna"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tipkovni prečaci"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Prikaži popis prečaca"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tipkovnice i alati radnog profila"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Tipkovnica na zaslonu za posao"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Zadano"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Dodirna podloga"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Dodirna podloga i miš"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Brzina pokazivača, pokreti"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Dodirni za klik"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Pokreti za dodirnu podlogu"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Prilagodba pojedinih pokreta za kretanje dodirnom podlogom"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Obrnuto pomicanje"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Sadržaj se pomiče prema gore kad se vi pomičete prema dolje"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Dodir u desnom donjem kutu"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Za više opcija dodirnite desni donji kut dodirne podloge"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Brzina pokazivača"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Učenje pokreta za dodirnu podlogu"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Na početni zaslon"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Prijeđite trima prstima nagore bilo gdje na dodirnoj podlozi"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Natrag"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Prijeđite od lijevog ili desnog ruba trima prstima"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Pregled nedavnih aplikacija"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Prijeđite trima prstima nagore, zadržite pa otpustite"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Pregled obavijesti i brzih postavki"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Prijeđite trima prstima nadolje na početnom zaslonu"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Promjena aplikacija"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Prijeđite četirima prstima ulijevo ili udesno"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Preskoči"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Dalje"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Pokreni ponovo"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Gotovo"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Natrag"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Prijeđite s tri prsta ulijevo ili udesno"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Na početni zaslon"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Prijeđite s tri prsta prema gore"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Nedavne aplikacije"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Prijeđite s tri prsta prema gore, a potom zadržite"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Obavijesti"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Prijeđite s tri prsta prema dolje"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Promjena aplikacija"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Prijeđite s četiri prsta ulijevo ili udesno"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifikatorske tipke"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Promjena ponašanja tipki"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Vrati sve na zadano"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Zadano"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Jeste li sigurni da sve modifikatorske tipke želite vratiti na zadano?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Gotovo"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Odustani"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Poništi"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Odaberi modifikatorsku tipku"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Odaberi novi ključ za <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Zadano"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Govor"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Brzina pokazivača"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Upravljač igrama"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Preusmjeri vibraciju"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Pošalji vibraciju igraćem kontroleru kada su povezani"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Odaberite izgled tipkovnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Postavljanje izgleda tipkovnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Za prijelaz pritisnite Ctrl i razmaknicu."</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Zadano"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Izgledi tipkovnice"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Izgledi fizičke tipkovnice"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Osobni rječnik"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Osobni rječnik za posao"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Dodajte riječi koje će se upotrebljavati u aplikacijama kao što je provjera pravopisa"</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">"U redu"</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čac:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Upišite riječ"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Neobavezni prečac"</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 biste dodali riječ, dodirnite gumb 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="keyboard_settings_summary" msgid="2716339620942356432">"Tipkovnica na zaslonu, govor, alati"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="6628668004523183413">"Tipkovnica na zaslonu, fizička tipkovnica, govor, alati"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fizička tipkovnica"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Izgled"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Odaberi gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Odaberite widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Želite izraditi widget i dozvoliti pristup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Kada izradite widget, aplikacija može pristupiti svemu što se prikazuje.\n\nAplikacija: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Uvijek dopusti aplikaciji <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> izradu widgeta i pristupanje njihovim podacima"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Korisnička statistika"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Poredaj po vremenu upotrebe"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Poredaj po zadnjoj upotrebi"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Poredaj po nazivu aplikacije"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Posljednja upotreba"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Vrijeme upotrebe"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Pristupačnost"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Postavke dostupnosti"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Zaslon, interakcija, zvuk"</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. Značajke pristupačnosti možete promijeniti kasnije u postavkama."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Promijenite veličinu fonta"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Čitač zaslona"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Titlovi"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Zvuk"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Općenito"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Zaslon"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Boja i pokret"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Zatamnjenje zaslona"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrole interakcije"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrole tajminga"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Kontrole sustava"</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 značajki"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtriranje Bluetooth HCI snoop loga"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Postavi filtre"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Onemogućite i omogućite Bluetooth da bi promjene stupile na snagu"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP filtriranje zapisa špijuniranja za Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP filtriranje zapisa špijuniranja za Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Postavite način filtriranja. (Onemogućite i omogućite Bluetooth da bi promjene stupile na snagu)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Da biste promijenili tu opciju, postavite način rada Bluetooth HCI snoop log na Omogućeno filtrirano"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Čitač zaslona namijenjen prvenstveno slijepim i slabovidnim osobama"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Dodirnite stavke na zaslonu za čitanje naglas"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Postavke titlova"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"O preferencijama za titlove"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Saznajte više o preferencijama za titlove"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Povećavanje"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Prečac za povećavanje"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Povećajte tipkanje"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Povećalo prati tekst dok ga tipkate"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Zadrži tijekom promjene aplikacije"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Povećalo ostaje uključeno i smanjuje prikaz kad promijenite aplikaciju"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Igraća palica"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktivirajte i pokrećite povećalo pomoću igraće palice na zaslonu. Dodirnite i zadržite, a zatim povucite igraću palicu da biste upravljali povećalom. Dodirnite i povucite da biste upravljali samom igraćom palicom."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"O povećavanju"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Saznajte više o povećavanju"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Vrsta povećavanja"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Povećajte cijeli zaslon ili određeno područje ili izmjenjujte obje opcije"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Cijeli zaslon"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Dio zaslona"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Izmjenjivanje djelomičnog i prikaza cijelog zaslona"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Odaberite način povećavanja"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Povećaj cijeli zaslon"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Povećaj dio zaslona"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Izmjenjivanje cijelog i djelomičnog prikaza zaslona"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Dodirnite gumb za prebacivanje da biste se prebacivali između opcija"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Prijeći na gumb za pristupačnost?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Trostruki dodir za povećavanje dijela zaslona uzrokuje kašnjenje u tipkanju i drugim radnjama.\n\nGumb za pristupačnost lebdi na zaslonu iznad drugih aplikacija. Dodirnite ga da biste povećali prikaz."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Prijeđi na gumb za pristupačnost"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Upotrijebi trostruki dodir"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"To može usporiti vašu tipkovnicu"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Kada upotrebljavate trostruki dodir za povećavanje dijela zaslona, možda ćete primijetiti probleme s tipkovnicom.\n\nDa biste to izbjegli, možete prečac za povećavanje promijeniti iz trostrukog dodira u neku drugu opciju.\n"<annotation id="link">"Promijenite postavku"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Ipak nastavi"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Odustani"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Postavke povećavanja"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Povećavanje trostrukim dodirom"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Povećanje pomoću prečaca"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Povećanje pomoću prečaca 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_text_reading_options_title" msgid="3224648909213325563">"Veličina prikaza i tekst"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Promijenite način prikazivanja teksta"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Predmet: Dizajni balona na vrući zrak"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Šalje: Branko"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Dobro jutro!\n\nSamo želim provjeriti kako napreduju dizajni. Hoće li biti spremni prije nego što počnemo s izradom novih balona?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Poništi postavke"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Postavke veličine zaslona i teksta vraćene su na zadano"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Želite li poništiti veličinu prikaza i tekst?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Poništi"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Što planiraš ovaj vikend?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Idem na plažu. Ideš sa mnom?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opcije"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Povećavanje zaslona"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Dodirnite triput za zumiranje"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Dodirnite gumb za zumiranje"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Brzo povećajte zaslon da bi se povećao prikaz sadržaja"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Da biste povećali prikaz:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Upotrijebite prečac da biste pokrenuli povećavanje.&lt;br/&gt; {1,number,integer}. Dodirnite zaslon.&lt;br/&gt; {2,number,integer}. Povlačite dva prsta da biste se pomicali po zaslonu.&lt;br/&gt; {3,number,integer}. Spojite dva prsta da biste prilagodili povećanje.&lt;br/&gt; {4,number,integer}. Upotrijebite prečac da biste zaustavili povećavanje.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Da biste privremeno povećali prikaz:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Provjerite je li odabrano povećavanje cijelog zaslona.&lt;br/&gt; {1,number,integer}. Upotrijebite prečac da biste pokrenuli povećavanje.&lt;br/&gt; {2,number,integer}. Dodirnite i zadržite bilo gdje na zaslonu.&lt;br/&gt; {3,number,integer}. Povlačite prst da biste se pomicali po zaslonu.&lt;br/&gt; {4,number,integer}. Podignite prst da biste zaustavili povećavanje."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kad je povećanje uključeno, možete povećati prikaz na zaslonu.\n\n"<b>"Da biste zumirali"</b>", pokrenite povećanje, a zatim dodirnite bilo gdje na zaslonu.\n"<ul><li>"Povlačite s dva prsta ili više njih da biste se pomicali."</li>\n<li>"Spojite dva prsta ili više njih da biste prilagodili zumiranje."</li></ul>\n\n<b>"Da biste nešto privremeno zumirali"</b>", pokrenite povećanje, a zatim dodirnite bilo gdje na zaslonu i zadržite pritisak.\n"<ul><li>"Povlačite prstom da biste se kretali zaslonom."</li>\n<li>"Podignite prst da biste smanjili prikaz."</li></ul>\n\n"Tipkovnica i navigacijska traka ne mogu se povećati."</string>
    <string name="accessibility_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">"Otvaranje pomoću gumba za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Zadržite tipke za glasnoću za otvaranje"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Triput dodirnite zaslon za otvaranje"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Otvaranje pokretom"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Upotreba pokreta za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Da biste koristili tu značajku, dodirnite gumb za Pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> pri dnu zaslona.\n\nDa biste prešli na neku drugu značajku, dodirnite i zadržite gumb za Pristupačnost."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Da biste koristili tu značajku, dodirnite gumb za pristupačnost na zaslonu."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Da biste koristili tu značajku, pritisnite i zadržite obje tipke za glasnoću."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Da biste pokrenuli ili zaustavili povećavanje, triput dodirnite bilo gdje na zaslonu."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Da biste koristili tu značajku, prijeđite s dva prsta prema gore od dna zaslona.\n\nDa biste prešli na neku drugu značajku, prijeđite s dva prsta prema gore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Da biste koristili tu značajku, prijeđite s tri prsta prema gore od dna zaslona.\n\nDa biste prešli na neku drugu značajku, prijeđite s tri prsta prema gore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Da biste koristili značajku pristupačnosti, prijeđite s dva prsta prema gore od dna zaslona.\n\nDa biste prešli na neku drugu značajku, prijeđite s dva prsta prema gore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Da biste koristili značajku pristupačnosti, prijeđite s tri prsta prema gore od dna zaslona.\n\nDa biste prešli na neku drugu značajku, prijeđite s tri prsta prema gore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Shvaćam"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Postavke gumba pristupačnosti"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Prečac za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Gumb za pristupačnost"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Pokret za pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Prijeđite s dva prsta prema gore"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Prijeđite s tri prsta prema gore"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Dodirnite gumb za pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Upotreba pokreta za pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Dodirnite gumb za Pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> pri dnu zaslona.\n\nDa biste prešli na neku drugu značajku, dodirnite i zadržite gumb za Pristupačnost."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Prijeđite s dva prsta prema gore od dna zaslona.\n\nDa biste prešli na neku drugu značajku, prijeđite s dva prsta prema gore i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Prijeđite s tri prsta prema gore od dna zaslona.\n\nDa biste prešli na neku drugu značajku, prijeđite s tri prsta prema gore i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Više opcija"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Saznajte više o usluzi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Držite tipke za glasnoću"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"držite tipke za glasnoću"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Pritisnite i zadržite obje tipke za glasnoću"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Triput dodirnite zaslon"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"triput dodirnite zaslon"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Brzo dodirnite zaslon {0,number,integer} puta. Taj prečac može usporiti 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">"Gumb Pristupačnost postavljen je na <xliff:g id="SERVICE">%1$s</xliff:g>. Da biste upotrijebili povećanje, dodirnite i zadržite gumb Pristupačnost i zatim odaberite povećanje."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Pokret pristupačnosti postavljen je tako da otvara <xliff:g id="SERVICE">%1$s</xliff:g>. Da biste koristili povećanje, s dva prsta prijeđite od dna zaslona prema gore i zadržite. Zatim odaberite povećanje."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Prečac tipki za glasnoću"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Postavke prečaca"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Prečac sa zaključanog zaslona"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Dopusti prečacu značajke da se uključi sa zaključanog zaslona. Pritisnite obje tipke za glasnoću na nekoliko sekundi."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Gumb za pristupačnost"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Gumb i pokret za pristupačnost"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Brzo pristupite značajkama pristupačnosti s bilo kojeg zaslona."</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"O gumbu za pristupačnost"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"O gumbu i pokretu za pristupačnost"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Saznajte više o gumbu i pokretu za pristupačnost"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Upotreba gumba za Pristupačnost. Pokret nije dostupan uz navigaciju pomoću tri gumba."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Brz pristup značajkama pristupačnosti"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Da biste započeli:"</b>\n"1. Otvorite postavke pristupačnosti.\n2. Odaberite značajku i dodirnite prečac.\n3. Odaberite hoćete li za pristup značajci koristiti gumb ili pokret."</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Da biste započeli:"</b>\n"1. Otvorite postavke pristupačnosti.\n2. Odaberite značajku i dodirnite prečac.\n3. Odaberite gumb za pristup značajci."</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Upotreba gumba ili pokreta"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Lokacija"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Veličina"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Blijedi kad se ne koristi"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Nakon nekoliko sekundi blijedi kako biste lakše mogli vidjeti zaslon"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Prozirnost kad se ne koristi"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Prozirno"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neprozirno"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst s visokim kontrastom"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mijenja boju teksta u crnu ili bijelu. Maksimizira kontrast s pozadinom."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Autom. ažuriranje uvećanja zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ažuriranje uvećanja zaslona pri izmjeni aplikacija"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Tipka za uklj. prekida poziv"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Veliki pokazivač miša"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Povećajte vidljivost pokazivača miša"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Uklanjanje animacija"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Smanjite pokrete na zaslonu"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Monozvuk"</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">"Ravnoteža 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 radnju (vrijeme čekanja za pristupačnost)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"O vremenu za radnju (vrijeme čekanja za pristupačnost)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Saznajte više o vremenu za radnju (vrijeme čekanja za pristupačnost)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Vrijeme za radnju"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Ta preferencija za tajming nije podržana u svim aplikacijama."</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Odaberite koliko će se dugo prikazivati privremene poruke kojima se traži da izvršite radnju"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Trajanje pritiska"</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_shortcut_title" msgid="6889624526691513462">"Prečac za inverziju boja"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Inverzijom boja svijetli zasloni postaju tamni, a tamni postaju svijetli."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Napomena&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Boje će se promijeniti u medijskim sadržajima i na slikama.&lt;/li&gt; &lt;li&gt; Inverzija boja funkcionira u svim aplikacijama.&lt;/li&gt; &lt;li&gt; Za prikaz tamne pozadine možete upotrebljavati tamnu temu.&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_about_title" msgid="152923024405552594">"O automatskom kliku (vrijeme zadržavanja)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Saznajte više o automatskom kliku (vrijeme zadržavanja)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Možete postaviti povezani miš tako da automatski klikne kad se pokazivač prestane kretati na određeno vrijeme"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automatsko klikanje može biti korisno ako vam je teško klikati mišem"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automatsko klikanje 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">"Dulje"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Trajanje automatskog klika"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibracija i haptika"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Upravljanje snagom vibracije za različite upotrebe"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Uključi"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Isključi"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Postavka je onemogućena jer je na uređaju isključen zvuk"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Pozivi"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Obavijesti i alarmi"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktivna haptika"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Koristi vibraciju i haptiku"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibracija alarma"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibracija medijskih sadržaja"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibracija pri zvonjenju"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibracija za obavijesti"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Reakcija na dodir"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Koristi uslugu <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Otvori <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Aplikacija <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> dodana je u Brze postavke. Prijeđite prstom prema dolje da biste je uključili ili isključili."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> također se može dodati u Brze postavke s vrha zaslona"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Korekcija boja dodana je u Brze postavke. Prijeđite prstom prema dolje da biste je uključili ili isključili."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Također možete dodati korekciju boja u Brze postavke s vrha zaslona"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Inverzija boja dodana je u Brze postavke. Prijeđite prstom prema dolje da biste je uključili ili isključili."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Također možete dodati inverziju boja u Brze postavke s vrha zaslona"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Dodatno zatamnjenje dodano je u Brze postavke. Prijeđite prstom prema dolje da biste ga uključili ili isključili."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Također možete dodati dodatno zatamnjenje u Brze postavke s vrha zaslona"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Način rada jednom rukom dodan je u Brze postavke. Prijeđite prstom prema dolje da biste ga uključili ili isključili."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Također možete dodati način rada jednom rukom u Brze postavke s vrha zaslona"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Veličina fonta dodana je u Brze postavke. Prijeđite prstom prema dolje da biste u bilo kojem trenutku promijenili veličinu fonta."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Odbaci"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Koristi korekciju boja"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Prečac za korekciju boja"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"O korekciji boja"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Saznajte više o korekciji boja"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"O inverziji boja"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Saznajte više o inverziji boja"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Prikaži titlove"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Samo za podržanu aplikaciju"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Veličina i stil titlova"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"<xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g> veličina teksta"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Više opcija"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Prilagodite veličinu i stil titlova kako biste ih lakše čitali."</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Te postavke titlova nisu podržane u svim aplikacijama za medijske sadržaje"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"gumb za Pristupačnost"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"prijeđite dvama prstima prema gore"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Držite tipke za glasnoću"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triput dodirnite zaslon"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Nastavi"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Slušni uređaji"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Možete koristiti slušne aparate, umjetne pužnice i druge uređaje za pojačanje sa svojim telefonom"</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_title" msgid="2357706801112207624">"Uparite slušna pomagala"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Na sljedećem zaslonu dodirnite svoja slušna pomagala. Možda ćete trebati upariti lijevo i desno uho zasebno.\n\nProvjerite jesu li slušna pomagala uključena i spremna za uparivanje."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"Aktivno: <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, samo lijevo"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, samo desno"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, lijevo i desno"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> i još jedan uređaj"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Upari novi uređaj"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"O uparivanju novog uređaja"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Slušni uređaji"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Spremljeni uređaji"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Kontrole slušnih uređaja"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Prečac za slušne uređaje"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilnost sa sluš. pomagalima"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Poboljšava kompatibilnost s telezavojnicama i smanjuje neželjenu buku"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"O slušnim uređajima"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Provjerite je li vaš slušni aparat uključen i spreman za uparivanje"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Uparite slušni uređaj"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupni slušni uređaji"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Ne vidite svoj slušni uređaj?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Pregled više uređaja"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Prilagodba zvuka"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audioopis"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Poslušajte opis događaja na zaslonu u podržanim filmovima i emisijama"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"audioopis, audio, opis, slabovidnost,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Prečac je uključen"</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">"Usluga ne radi. Dodirnite za informacije."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Usluga ne radi ispravno."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Prečaci za pristupačnost"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Prikaži u Brzim postavkama"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Crveno – zeleno"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Crveno – zeleno"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Plavo – žuto"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Nijanse sive"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Oslabljen osjet zelene boje, deuteranomalija"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Oslabljen osjet crvene boje, protanomalija"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalija"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Još tamnije"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Još zatamni"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Prečac za dodatno zatamnjenje"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"O dodatnom zatamnjenju"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Zatamnite zaslon kako vam ne bi blještao u oči dok čitate"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intenzitet"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Tamnije"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Svjetlije"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Zadrži nakon ponovnog pokretanja uređaja"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Kratko ({time} sekunda)}one{Kratko ({time} sekunda)}few{Kratko ({time} sekunde)}other{Kratko ({time} sekundi)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Srednje ({time} sekunda)}one{Srednje ({time} sekunda)}few{Srednje ({time} sekunde)}other{Srednje ({time} sekundi)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Dugo ({time} sekunda)}one{Dugo ({time} sekunda)}few{Dugo ({time} sekunde)}other{Dugo ({time} sekundi)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} s}one{{time} s}few{{time} s}other{{time} s}}"</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">"Zasjenjenost pozadine"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Boja pozadine titlova"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Neprozirnost pozadine titlova"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Boja teksta"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Neprozirnost teksta"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Boja ruba"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Vrsta ruba"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Obitelj fonta"</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">"Ništa"</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">"Grimizna"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Želite li dopustiti da <xliff:g id="SERVICE">%1$s</xliff:g> ima potpunu kontrolu nad uređajem?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> treba sljedeće:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Budući da aplikacija prekriva zahtjev za dopuštenje, Postavke ne mogu potvrditi vaš odgovor."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"Usluga <xliff:g id="SERVICE">%1$s</xliff:g> zahtijeva punu kontrolu nad ovim uređajem. Ta usluga može čitati zaslon i postupati u ime korisnika kojima je potrebna prilagođena pristupačnost. Ta razina kontrole nije primjerena za većinu aplikacija."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Potpuna kontrola prikladna je za aplikacije koje vam pomažu s potrebama pristupačnosti, ali ne i za većinu aplikacija."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Pregled zaslona i upravljanje njime"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Može čitati sav sadržaj na zaslonu i prikazati sadržaj povrh drugih aplikacija."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Pregled i izvršavanje radnji"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Može pratiti vaše interakcije s aplikacijama ili senzorom uređaja i stupati u interakciju s aplikacijama u vaše ime."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Dopusti"</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">"Odustani"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Želite li zaustaviti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Ako dodirnete <xliff:g id="STOP">%1$s</xliff:g>, zaustavit će se <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 nijedna usluga"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nije dan opis."</string>
    <string name="settings_button" msgid="2195468788019730377">"Postavke"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"osjetljivost na svjetlo, fotofobija, tamna tema, migrena, glavobolja, način za čitanje, noćni način rada, smanjenje svjetline, bijela točka"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Lakoća upotrebe, lakoća pristupa, pomoć, asistivno"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Alat za povećanje prozora, zumiranje, povećavanje, slabovidnost, povećati, uvećati"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Titlovi, Automatska transkripcija, nagluhost, gubitak sluha, računalni prijepis u stvarnom vremenu, pretvaranje govora u tekst"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"veličina zaslona, veliki zaslon"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Visoki kontrast, slabovidnost, podebljani font, podebljano"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"prilagodba boje"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"zatamniti zaslon, posvijetliti zaslon"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"kontrast boja"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motorika, miš"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"slušni aparati, nagluha osoba, gubitak sluha, umjetne pužnice, uređaji za pojačanje zvuka, uređaji za obradu zvuka"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"nagluhost, gubitak sluha, titlovi, teleprinter, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Ispis"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Isključeno"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{Uključena je 1 usluga ispisa}one{Uključena je # usluga ispisa}few{Uključene su # usluge ispisa}other{Uključeno je # usluga ispisa}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 zadatak ispisa}one{# zadatak ispisa}few{# zadatka ispisa}other{# zadataka ispisa}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Usluge ispisa"</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 pisač"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Postavke"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Dodavanje pisača"</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">"Dodajte pisač"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Pretražite"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Traženje pisača"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Usluga je onemogućena"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Zadaci ispisa"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Zadatak ispisa"</string>
    <string name="print_restart" msgid="4424096106141083945">"Ponovo pokreni"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Odustani"</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 zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Ispisivanje zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Otkazivanje zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Pogreška pisača <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Pisač 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 prikazan je"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Okvir za pretraživanje skriven je"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Više informacija o ovom pisaču"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterija"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Što troši bateriju"</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 je <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 dovršetka punjenja"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Slaba baterija"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Dopustite rad aplikacije u pozadini"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Želite li ograničiti pozadinsku aktivnost?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ako ograničite pozadinsku aktivnost za aplikaciju, možda će se ponašati nepredviđeno"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Aplikacija nije postavljena za optimizaciju baterije, pa je ne možete ograničiti.\n\nZa ograničenje uključite optimizaciju."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Neograničeno"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimizirano"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Ograničeno"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Dopusti neograničenu potrošnju baterije prilikom rada u pozadini. To može povećati potrošnju baterije."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimiziraj na temelju potrošnje. Preporučeno za većinu aplikacija."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Ograniči potrošnju baterije dok radi u pozadini. Aplikacija možda neće pravilno funkcionirati. Obavijesti mogu kasniti."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Promjena načina na koji aplikacija troši bateriju može utjecati na njezinu izvedbu."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Ova aplikacija zahtijeva potrošnju baterije (<xliff:g id="STATE">%1$s</xliff:g>)."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"neograničeno"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimizirano"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Saznajte više o opcijama potrošnje baterije"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Upotreba zaslona od potpunog punjenja"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Potrošnja baterije"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalji povijesti"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Potrošnja baterije"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Prikaz potrošnje u posljednja 24 sata"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Pregled upotrebe od zadnjeg potpunog punjenja"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Potrošnja baterije za aplikaciju"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detalji upotrebe"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Podesi potrošnju energije"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Uključeni paketi"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikacije se izvode na uobičajen način"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Niska razina baterije"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Uključite štednju baterije radi produljenja trajanja baterije"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Produljenje trajanja baterije"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Uključite Battery Manager"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Uključite Štednju baterije"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Baterija bi se mogla isprazniti brže nego obično"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Štednja baterije uključena"</string>
    <string name="battery_saver_link_a11y" msgid="740558184830458845">"Saznajte više o štednji baterije"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Neke značajke mogu biti ograničene"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Velika potrošnja baterije"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Pogledajte aplikacije s najvećom potrošnjom baterije"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Punjenje se optimizira radi zaštite baterije"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="6836981984725209843">"Radi produljenja trajanja baterije, punjenje se optimizira"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Punjenje se optimizira radi zaštite baterije"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Radi produljenja trajanja baterije, punjenje se optimizira dok je uređaj na priključnoj stanici"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Punjenje se optimizira radi zaštite baterije"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Radi produljenja trajanja baterije, punjenje se optimizira dok je uređaj na priključnoj stanici"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Punjenje do kraja"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Radi zaštite baterije, punjenje će se optimizirati kada tablet sljedeći put bude na priključnoj stanici"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Saznajte više o pauziranom punjenju"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Nastavi s punjenjem"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Uključuje aktivnost u pozadini s visokom potrošnjom energije"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Ograniči # aplikaciju}one{Ograniči # aplikaciju}few{Ograniči # aplikacije}other{Ograniči # aplikacija}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} nedavno ograničena}one{# aplikacija nedavno ograničena}few{# aplikacije nedavno ograničene}other{# aplikacija nedavno ograničeno}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} ima veliku potrošnju baterije u pozadini}one{# aplikacija ima veliku potrošnju baterije u pozadini}few{# aplikacije imaju veliku potrošnju baterije u pozadini}other{# aplikacija ima veliku potrošnju baterije u pozadini}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Ova se aplikacija ne može izvoditi u pozadini}one{Ove se aplikacije ne mogu izvoditi u pozadini}few{Ove se aplikacije ne mogu izvoditi u pozadini}other{Ove se aplikacije ne mogu izvoditi u pozadini}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Želite li ograničiti aplikaciju?}one{Želite li ograničiti # aplikaciju?}few{Želite li ograničiti # aplikacije?}other{Želite li ograničiti # aplikacija?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Da biste uštedjeli bateriju, onemogućite da <xliff:g id="APP">%1$s</xliff:g> troši bateriju u pozadini. Ta aplikacija možda neće funkcionirati pravilno i obavijesti mogu kasniti."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Da biste uštedjeli bateriju, onemogućite da aplikacije navedene u nastavku troše bateriju u pozadini. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu kasniti.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Da biste uštedjeli bateriju, onemogućite da aplikacije navedene u nastavku troše bateriju u pozadini. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu kasniti.\n\nAplikacije:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Ograniči"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Želite li ukloniti ograničenje?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Ta će aplikacija moći upotrebljavati bateriju u pozadini. Baterija bi se mogla isprazniti brže nego što očekujete."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Ukloni"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Odustani"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Napuni do kraja"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problem s priborom za punjenje"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Saznajte više o punjenju pomoću nekompatibilnog adaptera"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Battery Manager"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Automatski upravljaj aplikacijama"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kada Battery Manager otkrije da aplikacije prazne bateriju, moći ćete ograničiti te aplikacije. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu kasniti."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Ograničene aplikacije"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Ograničava se potrošnja baterije za # aplikaciju}one{Ograničava se potrošnja baterije za # aplikaciju}few{Ograničava se potrošnja baterije za # aplikacije}other{Ograničava se potrošnja baterije za # aplikacija}}"</string>
    <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="3495725286882138803">"Tim je aplikacijama ograničena potrošnja baterije u pozadini. Možda neće funkcionirati u skladu s očekivanjima i obavijesti mogu kasniti."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Upotreba Battery Managera"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Otkriva kada aplikacije prazne bateriju"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Otkrivanje kad aplikacije prazne bateriju"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Otkrivanje kad aplikacije prazne bateriju"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# aplikacija ograničena}one{# aplikacija ograničena}few{# aplikacije ograničene}other{# aplikacija ograničeno}}"</string>
    <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="400958471814422770">"Problem s očitavanjem mjerača baterije."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Dodirnite da biste saznali više o toj pogrešci"</string>
    <string name="power_screen" msgid="3926703168513988776">"Zaslon"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Svjetiljka"</string>
    <string name="power_camera" msgid="4778315081581293923">"Fotoaparat"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobilna mreža"</string>
    <string name="power_phone" msgid="2768396619208561670">"Glasovni pozivi"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Upotreba zaslona <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="APP">%2$s</xliff:g> upotrebljava <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 potrošnje baterije"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Razrada od posljednjeg potpunog punjenja"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Posljednje potpuno punjenje"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Potpuna napunjenost traje oko"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Preostalo vrijeme trajanja baterije približno je i može se mijenjati ovisno o upotrebi"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Potrošnja baterije"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Nema upotrebe od zadnjeg potpunog punjenja"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Nema potrošnje u posljednja 24 h"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"od zadnjeg potpunog punjenja"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Aplikacije sustava"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Ostalo"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Procijenjeno preostalo vrijeme"</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 ovisno o upotrebi"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Medijski poslužitelj"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimizacija aplikacija"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Modemsko povezivanje"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Uklonjene aplikacije"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Štednja baterije"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Uključi automatski"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Nema rasporeda"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Na temelju vaše rutine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Uključit će se na temelju vaše rutine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Na temelju postotka"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Štednja baterije uključuje se ako bi se baterija mogla isprazniti prije uobičajenog vremena 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">"Produljenje trajanja baterije"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Isključi nakon punjenja"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Isključi na <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Štednja baterije isključuje se kada razina napunjenosti dosegne <xliff:g id="BATTERY_PERCENTAGE">%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 štednju baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Uključi automatski"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikada"</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 baterije"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Prikaži postotak baterije na traci statusa"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Razina baterije od zadnjeg potpunog punjenja"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Razina baterije u posljednja 24 sata"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Upotreba aplikacija od posljednjeg potpunog punjenja"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Upotreba aplikacija u posljednja 24 sata"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Upotreba sustava od zadnjeg potpunog punjenja"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Upotreba sustava u posljednja 24 sata"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Upotreba sustava za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Upotreba aplikacije za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <!-- no translation found for battery_system_usage_since_last_full_charge_to (4196795733829841971) -->
    <skip />
    <!-- no translation found for battery_app_usage_since_last_full_charge_to (4339201995118102114) -->
    <skip />
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Ukupno: manje od minute"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"U pozadini: manje od minute"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Vrijeme upotrebe: manje od minute"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Ukupno: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"U pozadini: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Vrijeme upotrebe: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Podaci o potrošnji baterije postat će dostupni za nekoliko sati nakon što se baterija potpuno napuni"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"sad"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> – <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Grafikon potrošnje baterije"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Grafikon dnevne potrošnje baterije"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Grafikon potrošnje baterije po satima"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Potrošnja baterije od zadnjeg potpunog punjenja"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Potrošnja baterije za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Vrijeme upotrebe od zadnjeg potpunog punjenja"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Vrijeme upotrebe za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_breakdown_by_apps" msgid="7746337368402445072">"Raščlamba po aplikacijama"</string>
    <string name="battery_usage_spinner_breakdown_by_system" msgid="4646952798665973464">"Raščlamba po sustavu"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistički podaci o procesima"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Detaljni statistički podaci o trenutačnim procesima"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Upotreba memorije"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Iskorišteno <xliff:g id="USEDRAM">%1$s</xliff:g> od <xliff:g id="TOTALRAM">%2$s</xliff:g> tijekom <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"Iskorišteno <xliff:g id="PERCENT">%1$s</xliff:g> RAM-a tijekom <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Pozadina"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Prednji plan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Spremljeno u privremenu memoriju"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"OS Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Nativni procesi"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Jezgra sustava"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Predmemorije"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Iskorištenost RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Iskorištenost RAM-a (u pozadini)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Vrijeme izvođenja"</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">"Informacije 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 sustav"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Sakrij sustav"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Prikaži postotke"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Upotrijebi USS"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Vrsta statističkih podataka"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Pozadina"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Prednji plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Spremljeno u privremenu memoriju"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Glas. ulaz i izlaz"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Postavke za glasovni unos i izlazne vrijednosti"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Glasovno pretraživanje"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android tipkovnica"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Postavke glasovnog unosa"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Glasovni unos"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Usluge glasovnog unosa"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Potpuni pokretač značajki 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">"Usluga glasovnog unosa moći će u vaše ime neprekidno nadzirati glasovne unose i kontrolirati aplikacije s omogućenom glasovnom interakcijom. Pruža je <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Želite li omogućiti tu uslugu?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Postavke prepoznavanja na uređaju"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Prepoznavanje na uređaju"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Prepoznavanje govora na uređaju"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Željeni alat"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Postavke alata"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Brzina govora i visina glasa"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Alat"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Govorni jezik"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instaliranje glasova"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Nastavite u aplikaciju <xliff:g id="TTS_APP_NAME">%s</xliff:g> da biste instalirali glasove"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Otvori aplikaciju"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Odustani"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Vrati na zadano"</string>
    <string name="tts_play" msgid="2945513377250757221">"Reproduciraj"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nije sigurno"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"Nije sigurno: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"Nije sigurno: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Prilagodljivo povezivanje"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Automatski upravlja mrežnim vezama i tako produljuje trajanje baterije i poboljšava izvedbu uređaja"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Uključeno"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Isključeno"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Upotreba prilagodljivog povezivanja"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Pohrana vjerodajnica"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instaliranje certifikata"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Brisanje vjerodajnica"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Uklanjanje svih certifikata"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Pouzdane vjerodajnice"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Prikaz pouzdanih CA certifikata"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Korisničke vjerodajnice"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Prikaz i izmjena pohranjenih vjerodajnica"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Dodatne postavke"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Za ovog korisnika nisu dostupne vjerodajnice"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instalirano za VPN i aplikacije"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Instalirano za Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Instalirano za Wi-Fi (u upotrebi)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Ukloniti sve sadržaje?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Pohrana vjerodajnica izbrisana je."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Pohrana vjer. nije izbrisana."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apl. s pristupom pod. o upot."</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA certifikat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Korisnički certifikat za VPN i aplikacije"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certifikat za Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Vaši podaci neće biti privatni"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA certifikate koriste web-lokacije, aplikacije i VPN-ovi za šifriranje. Instalirajte CA certifikate samo od organizacija kojima vjerujete. \n\nAko instalirate CA certifikat, vlasnik certifikata mogao bi pristupiti vašim podacima, kao što su zaporke ili pojedinosti o kreditnim karticama, s web-lokacija koje posjećujete ili iz aplikacija koje upotrebljavate, čak i ako su vaši podaci šifrirani."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ne instaliraj"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Svejedno instaliraj"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certifikat nije instaliran"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Dopustiti aplikaciji "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" da instalira certifikate na ovom uređaju?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Ti će certifikati potvrditi vaš identitet tako što će podijeliti jedinstveni ID uređaja s aplikacijama i URL-ovima u nastavku"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nemoj dopustiti"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Dopusti"</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="8507306554200869005">"Certifikati će potvrditi vaš identitet kada upotrebljavate aplikacije i URL-ove u nastavku"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Deinstaliraj certifikate"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Ukloni aplikaciju"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Ukloniti aplikaciju?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Ta aplikacija neće upravljati certifikatima, no ostat će na vašem uređaju. Svi certifikati koje je instalirala ta aplikacija deinstalirat će se."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}one{# URL}few{# URL-a}other{# URL-ova}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signal za hitne pozive"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Postavite način ponašanja za hitni poziv"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Sigurnosno kopiranje"</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">"Osobni podaci"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Sigurnosno kopiranje"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Stvaranje sigurnosne kopije podataka aplikacije, Wi-Fi zaporki i ostalih postavki na Googleovim poslužiteljima"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Sigurnosni račun"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Upravljanje računom za sigurnosno kopiranje"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Uključi podatke aplikacija"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatsko vraćanje"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Pri ponovnoj instalaciji aplikacije vratiti postavke i podatke za koje su stvorene sigurnosne kopije"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Usluga sigurnosnog kopiranja nije aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Nijedan račun trenutno ne stvara sigurnosne kopije podataka"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Želite li zaustaviti stvaranje sigurnosnih kopija Wi-Fi zaporki, oznaka, drugih postavki i podataka aplikacija te izbrisati sve kopije na Googleovim poslužiteljima?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Želite li zaustaviti sigurnosno kopiranje podatka s uređaja (kao što su zaporke za Wi-Fi i povijest poziva) i podataka aplikacija (kao što su postavke i datoteke koje aplikacije spremaju) te izbrisati sve kopije na udaljenim poslužiteljima?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Daljinski pokrenite automatsku izradu sigurnosne kopije podataka uređaja (kao što su zaporke Wi-Fija i povijest poziva) i podataka aplikacija (kao što su postavke i datoteke koje aplikacije pohranjuju).\n\nKada uključite automatsku izradu sigurnosnih kopija, podaci uređaja i aplikacija periodično se daljinski spremaju. Podaci aplikacije mogu biti bilo koji podaci koje je aplikacija spremila (na temelju postavki razvojnog programera), uključujući potencijalno osjetljive podatke kao što su kontakti, poruke i fotografije."</string>
    <string name="device_admin_settings_title" msgid="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 tu 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">"Agenti za pouzdanost nisu dostupni"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivirati apl. administratora uređaja?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiviraj tu aplikaciju administratora uređaja"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrator uređaja"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Aktiviranjem ove administratorske aplikacije dopustit ćete aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> izvođenje sljedećih radnji:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Ovim će uređajem upravljati <xliff:g id="APP_NAME">%1$s</xliff:g> i nadzirati ga."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Ova je administratorska aplikacija aktivna i omogućuje aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> izvođenje sljedećih radnji:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Želite li aktivirati upravitelj profila?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Dopuštate li nadzor?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ako nastavite, vašim će korisnikom upravljati administrator, koji uz vaše osobne podatke može spremiti i povezane podatke.\n\nVaš administrator može nadzirati postavke, pristup, aplikacije i podatke povezane s tim korisnikom, uključujući aktivnosti na mreži i podatke o lokaciji uređaja te njima upravljati."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Ostale je opcije onemogućio vaš administrator"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Saznajte više"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Zapisnik obavijesti"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Povijest obavijesti"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Zadnjih %d h"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Odgođeno"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nedavno odbačeno"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# obavijest}one{# obavijest}few{# obavijesti}other{# obavijesti}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Melodija zvona i vibriranje za poziv"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Pojedinosti o mreži"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinkronizacija je omogućena"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Onemogućena je sinkronizacija"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sinkronizacija u tijeku"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Pogreška sinkronizacije"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinkronizacija nije uspjela"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinkronizacija aktivna"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinkronizacija"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sinkronizacija trenutačno ima problema. Uskoro će nastaviti s radom."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Dodajte račun"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Poslovni profil još nije dostupan"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Poslovni profil"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Profilom upravlja vaša organizacija"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Isključene su aplikacije i obavijesti"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Ukloni poslovni profil"</string>
    <string name="background_data" msgid="321903213000101158">"Pozadinski podaci"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikacije mogu sink., slati i primati podatke bilo kad"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Onem. poz. podatke?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Onemogućavanje pozadinskih podataka produljuje trajanje baterije i smanjuje upotrebu podataka. Neke aplikacije još uvijek mogu upotrebljavati pozadinsku podatkovnu vezu."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sink. uključena"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sink. ISKLJUČENA"</string>
    <string name="sync_error" msgid="846923369794727644">"Pogreška sink."</string>
    <string name="last_synced" msgid="1527008461298110443">"Posljednja sinkronizacija: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sinkronizacija u tijeku…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Postavke sigurnosne kopije"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Stvori sigurnosnu kopiju postavki"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinkroniziraj sada"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Otkaži sinkronizaciju"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Dodirnite da biste sinkronizirali 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="header_application_sync_settings" msgid="7427706834875419243">"Postavke sinkronizacije aplikacije"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Podaci i sinkronizacija"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Promijeni zaporku"</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">"Želite li ukloniti račun?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Vaš administrator ne dopušta tu promjenu"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nije moguća ručna sinkronizacija"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Sinkronizacija za tu stavku trenutačno je onemogućena. Da biste promijenili tu postavku, privremeno uključite pozadinske podatke i automatsku sinkronizaciju."</string>
    <string name="delete" msgid="8330605554706263775">"Izbriši"</string>
    <string name="select_all" msgid="7898929601615536401">"Odaberi sve"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Podatkovni promet"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobilni podaci i Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Aut. sinkr. osobne podatke"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Aut. sinkr. poslovne podatke"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Promjena ciklusa..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dan u mjesecu za poništavanje ciklusa upotrebe podataka:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"U tom razdoblju aplik. nisu upotreblj. podatke."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Prednji 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 mobilne podatke?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Ograničenje za mobilne podatke"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Postavi ograničenje za 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Postavi ograničenje za 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Ograniči podatke za Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilno"</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">"Mobilni uređaj"</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">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Prednji 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ći upotrebu mobilnih podataka u pozadini"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Za ograničenje poz. podat. za ovu apl. ograničite mob. podatke."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Ograničenje pozadinskih podataka?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Zbog te značajke aplikacija koja ovisi o pozadinskim podacima može prestati raditi kada su dostupne samo mobilne mreže.\n\nU postavkama možete pronaći prikladnije kontrole prijenosa podataka."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Ograničavanje pozadinskih podataka moguće je samo ako ste postavili ograničenje mobilnog podatkovnog prometa."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Uključiti auto. sinkronizaciju?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Isključiti auto. sinkronizaciju?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Time će se uštedjeti na podatkovnom prometu i smanjiti potrošnja baterije, ali svaki ćete račun morati ručno sinkronizirati kako biste dobili najnovije informacije. Nećete primati obavijesti o ažuriranjima."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Datum poništavanja ciklusa potrošnje"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Datum u mjesecu:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Postavi"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Postavite upozorenje o potrošnji podataka"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Postavite ograničenje podatkovnog prometa"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Ograničenje podatkovnog prometa"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="12">"Upozori na"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="12">"Ograničeno na"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Uklonjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Uklonjene aplikacije i korisnici"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Upotreba mreže"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"S ograničenim prometom"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Naziv"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Vrsta"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa poslužitelja"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP enkripcija (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"tajna L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"IPSec unaprijed dijeljeni 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 poslužitelja"</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 poslužitelji (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">"Zaporka"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Spremi podatke o računu"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ne koristi se)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ne potvrđuj poslužitelj)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(primljen od poslužitelja)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Ova vrsta VPN-a ne podržava stalnu vezu"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Uvijek uključeni VPN podržava samo numeričke adrese poslužitelja"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Za uvijek uključeni VPN mora biti naveden DNS poslužitelj"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Adrese DNS poslužitelja za uvijek uključeni VPN moraju biti numeričke"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Uneseni podaci ne podržavaju uvijek uključeni VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Odustani"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Odbaci"</string>
    <string name="vpn_save" msgid="683868204634860888">"Spremi"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Poveži"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Zamijeni"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Uređivanje VPN profila"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Zaboravi"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Povezivanje s profilom <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Prekinuti vezu s VPN-om?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Prekini vezu"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Verzija"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Zaboravi VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Želite li zamijeniti dosadašnji VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Želite li postaviti uvijek uključeni VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Kada je ta postavka uključena, nećete imati internetsku vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Vaš dosadašnji VPN zamijenit će se i nećete imati internetsku vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Već ste povezani s uvijek uključenim VPN-om. Ako se povežete s nekim drugim VPN-om, on će zamijeniti dosadašnji, a način rada \"uvijek uključeno\" isključit će se."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Već ste povezani s VPN-om. Ako se povežete s nekim drugi VPN-om, on će zamijeniti dosadašnji."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Uključi"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Povezivanje s <xliff:g id="VPN_NAME">%1$s</xliff:g> mrežom nije uspjelo"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Ova aplikacija ne podržava uvijek uključeni VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Dodavanje VPN profila"</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 uključena VPN mreža"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nije dodan nijedan VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Održavaj stalnu vezu s VPN-om"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Ova aplikacija ne podržava tu opciju"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Uvijek uključeno"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nije sigurno"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokiraj veze bez VPN-a"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Zahtijevati VPN vezu?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nije sigurno. Ažurirajte na IKEv2 VPN"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Odaberite VPN profil s kojim ćete uvijek biti povezani. Mrežni promet bit će dopušten samo kada ste povezani s tom VPN mrežom."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Ništa"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Uvijek uključena VPN mreža zahtijeva IP adresu za poslužitelj 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">"Prekinuta veza s VPN-om"</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">"Sustav"</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="8296330919329489422">"Deinstaliraj"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Smatraj pouzdanim"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Želite li omogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Želite li onemogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Želite li trajno ukloniti korisnički CA certifikat?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Koristi"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Ovaj unos sadrži"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 korisnički ključ"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 korisnički certifikat"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA certifikat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA certifikati"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Pojedinosti o vjerodajnicama"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Uklonjena vjerodajnica: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nema instaliranih korisničkih vjerodajnica"</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 trenutačnu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Ovdje upišite novu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Ovdje ponovo unesite novu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Postavi zaporku za sigurnosnu kopiju"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Odustani"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Dodatna ažuriranja sustava"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Mreža se možda nadzire"</string>
    <string name="done_button" msgid="6269449526248267">"Završeno"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Označite certifikat kao pouzdan ili ga uklonite}one{Označite certifikate kao pouzdane ili ih uklonite}few{Označite certifikate kao pouzdane ili ih uklonite}other{Označite certifikate kao pouzdane ili ih uklonite}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{Domena {orgName} instalirala je izdavač certifikata na vašem uređaju, što joj može omogućiti nadzor nad aktivnostima vašeg uređaja na mreži, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tom certifikatu zatražite od administratora.}one{Domena {orgName} instalirala je izdavače certifikata na vašem uređaju, što joj može omogućiti nadzor nad aktivnostima vašeg uređaja na mreži, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tim certifikatima zatražite od administratora.}few{Domena {orgName} instalirala je izdavače certifikata na vašem uređaju, što joj može omogućiti nadzor nad aktivnostima vašeg uređaja na mreži, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tim certifikatima zatražite od administratora.}other{Domena {orgName} instalirala je izdavače certifikata na vašem uređaju, što joj može omogućiti nadzor nad aktivnostima vašeg uređaja na mreži, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tim certifikatima zatražite od administratora.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{Domena {orgName} instalirala je izdavač certifikata za vaš poslovni profil, što joj može omogućiti nadzor nad aktivnostima poslovne mreže, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tom certifikatu zatražite od administratora.}one{Domena {orgName} instalirala je izdavače certifikata za vaš poslovni profil, što joj može omogućiti nadzor nad aktivnostima poslovne mreže, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tim certifikatima zatražite od administratora.}few{Domena {orgName} instalirala je izdavače certifikata za vaš poslovni profil, što joj može omogućiti nadzor nad aktivnostima poslovne mreže, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tim certifikatima zatražite od administratora.}other{Domena {orgName} instalirala je izdavače certifikata za vaš poslovni profil, što joj može omogućiti nadzor nad aktivnostima poslovne mreže, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o tim certifikatima zatražite od administratora.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Treća je strana u mogućnosti pratiti vašu mrežnu aktivnost, uključujući e-poštu, aplikacije i sigurne web-lokacije.\n\nTo omogućuje pouzdana vjerodajnica koja je instalirana na vašem uređaju."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Provjeri certifikat}one{Provjeri certifikate}few{Provjeri certifikate}other{Provjeri certifikate}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Više korisnika"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Korisnici i profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Dodavanje korisnika ili profila"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Ograničeni profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nije postavljen"</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 – poslovni 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="3328539978480663740">"Ne možete dodati više korisnika. Uklonite korisnika biste dodali novog."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Ograničeni profili ne mogu dodavati račune"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"<xliff:g id="USER_NAME">%1$s</xliff:g>: brisanje s uređaja"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Postavke zaključavanja zaslona"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Dodavanje korisnika sa zaključanog zaslona"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Na priključnoj stanici prijeđi na administratora"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Želite li izbrisati ovog korisnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Ukloniti profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Ukloniti poslovni profil?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Izbrisat će se sve aplikacije i podaci."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Ako nastavite, izbrisat će se sve aplikacije i podaci na profilu."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Izbrisat će se sve aplikacije i podaci."</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_exit_guest_confirm_message" msgid="8995296853928816554">"Izbrisat će se sve aplikacije i podaci u ovoj sesiji."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Ukloni"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Gost (vi)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Korisnici"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Drugi korisnici"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Izbriši aktivnost gostujuće sesije"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Izbriši sve aplikacije i podatke gostujuće sesije prilikom izlaska iz načina rada za goste"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Izbrisati aktivnost gosta?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Aplikacije i podaci iz ove gostujuće sesije izbrisat će se odmah, a sve buduće aktivnosti gostujuće sesije izbrisat će se svaki put kad napustite način rada za goste."</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"izbrisati, gost, aktivnost, ukloniti, podaci, posjetitelj, ukloniti"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Dopustite gostu upotrebu telefona"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Povijest poziva dijelit će se s gostom"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Uključivanje telefonskih poziva i SMS-a"</string>
    <!-- no translation found for user_grant_admin (5942118263054572074) -->
    <skip />
    <string name="user_remove_user" msgid="8468203789739693845">"Brisanje korisnika"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Želite li uključiti telefonske pozive i SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Povijest poziva i SMS-ova dijelit će se s tim korisnikom."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Ukloniti administratorske ovlasti?"</string>
    <!-- no translation found for user_revoke_admin_confirm_message (9207187319308572958) -->
    <skip />
    <string name="emergency_info_title" msgid="8233682750953695582">"Podaci za hitne slučajeve"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Podaci i kontakti za korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Otvori aplikaciju <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Dopuštanje aplikacija i sadržaja"</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="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Odaberite aplikacije za instalaciju"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Instaliranje dostupnih aplikacija"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Beskontaktna plaćanja"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Zadana aplikacija za plaćanje"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Za plaćanje pomoću aplikacije za plaćanje, stražnju stranu uređaja prislonite na terminal za plaćanje"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Saznajte više"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Postaviti poslovnu aplikaciju kao zadanu aplikaciju za plaćanje?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Za plaćanje pomoću poslovne aplikacije:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"poslovni profil mora biti uključen"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"trebat ćete unijeti PIN, uzorak ili zaporku poslovnog profila ako ih imate."</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">"Zadano 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="6127665705799658860">"Upotreba zadane aplikacije za plaćanje"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Upotreba zadane aplikacije za plaćanje"</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 beskontaktnom terminalu plaćat će se putem aplikacije:"</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 samo prislonite stražnju stranu telefona na bilo koji terminal sa simbolom beskontaktnog plaćanja."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Shvaćam"</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 beskontaktnom terminalu plaćat će se putem aplikacije <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Na beskontaktnom terminalu plaćat će se putem aplikacije <xliff:g id="APP_0">%1$s</xliff:g>.\n\nTo znači da <xliff:g id="APP_1">%2$s</xliff:g> više neće biti vaša 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="nfc_work_text" msgid="2496515165821504077">"Posao"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Ograničenja"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Uklanjanje ograničenja"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Promjena PIN-a"</string>
    <string name="help_label" msgid="2896538416436125883">"Pomoć/povratne inf."</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">"Primanje upozorenja za ekstremne prijetnje po život i imovinu"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ozbiljne prijetnje"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Primanje upozorenja za ozbiljne prijetnje po život i imovinu"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER upozorenja"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Primanje biltena o otmicama djece"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Ponovi"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Omogući Upravitelj poziva"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Dopusti usluzi upravljanje načinom uspostavljanja poziva."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Upravitelj poziva"</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">"Pristupne točke"</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">"4G pozivanje"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Upotreba LTE usluga za poboljšanje glasovnih poziva (preporučeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Upotreba 4G usluga za poboljšanje glasovnih poziva (preporučeno)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Upotreba 5G-a za glasovne pozive"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Slanje kontakata mobilnom operateru"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Slanje telefonskih brojeva kontakata radi pružanja poboljšanih značajki"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Slati 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">"Slati kontakte mobilnom operateru?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Telefonski brojevi vaših kontakata periodički će se slati mobilnom operateru <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Na temelju tih podataka utvrđuje se mogu li vaši kontakti upotrebljavati određene značajke, na primjer videopozive ili neke značajke slanja poruka."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Telefonski brojevi vaših kontakata periodički će se slati vašem mobilnom operateru.<xliff:g id="EMPTY_LINE">

</xliff:g>Na temelju tih podataka utvrđuje se mogu li vaši kontakti upotrebljavati određene značajke, na primjer videopozive ili neke značajke slanja poruka."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Željena 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 dok su mobilni podaci isključeni"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Automatski prebaci mobilne podatke"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Koristi ovu mrežu kad je dostupnija"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Radni SIM"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Pristup aplikacijama i sadržaju"</string>
    <string name="user_rename" msgid="8735940847878484249">"PREIMENOVANJE"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Postavljanje ograničenja aplikacije"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontrolira aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Ta aplikacija može pristupiti vašim računima"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Aplikacija može pristupili vašim računima. Upravlja aplikacija <xliff:g id="APP">%1$s</xliff:g>."</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi i mobilne mreže"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Dopusti izmjenu postavki Wi‑Fi i mobilne mreže"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Dopusti izmjene uparivanja i postavki Bluetootha"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Dopusti aplikacijama da upotrebljavaju podatke o lokaciji"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Natrag"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Dalje"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatiraj na drugi način"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM-ovi"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobilni podaci nisu dostupni"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Dodirnite da biste odabrali podatkovni SIM"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Uvijek upotrebljavaj za pozive"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Odaberite SIM za mobilne podatke"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Odaberite SIM za SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Prebacuje se podatkovni SIM, to može potrajati najviše minutu…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Koristiti <xliff:g id="NEW_SIM">%1$s</xliff:g> za mobilne podatke?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Ako prijeđete na mobilnog operatera <xliff:g id="NEW_SIM">%1$s</xliff:g>, operater <xliff:g id="OLD_SIM">%2$s</xliff:g> više se neće koristiti za mobilne podatke."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Upotrijebite <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Poziv putem usluge"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Unesite naziv SIM-a"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Utor za SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Narančasta"</string>
    <string name="color_purple" msgid="6603701972079904843">"Ljubičasta"</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_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="2819551384383504031">"SIM-ovi promijenjeni."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Dodirnite za postavljanje"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Pitaj svaki put"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Potreban je odabir"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Odabir SIM-a"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Postavke"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Mreža i internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobilna mreža, Wi‑Fi, žarišna točka"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, žarišna točka"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Povezani uređaji"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, uparivanje"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, način za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, način 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 za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, način 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">"Za upotrebu najprije instalirajte aplikaciju za plaćanje"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedavne aplikacije, zadane aplikacije"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Pristup obavijestima nije dostupan za aplikacije u radnom profilu."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Zaporke i računi"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Spremljene zaporke, automatsko popunjavanje, sinkronizirani računi"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Zadane aplikacije"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Klonirane aplikacije"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Izradite drugu instancu aplikacije kako biste mogli upotrebljavati dva računa istodobno."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Aplikacije koje se mogu klonirati."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Klonirano: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>, dostupno za kloniranje <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Izbriši sve klonove aplikacije"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Brisanje svih klonova apl. nije uspjelo"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Izrada…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Klonirano"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Izrađuje se klon za <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Izrađen je klon za <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Jezici, pokreti, vrijeme, sigurnosna kopija"</string>
    <string name="languages_setting_summary" msgid="4924440599794956443">"Jezici sustava, jezici aplikacije"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, mrežna veza, internet, bežično, podaci, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wi‑Fi obavijest, wifi obavijest"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"potrošnja podataka"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Koristi 24-satni format"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Otvori u aplikaciji"</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">"Oblačić za chat, sustav, upozorenje, prozor, dijalog, zaslon, iznad drugih aplikacija, povući"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Svjetiljka, svjetlo, bljeskalica"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, promjena, upravljanje"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilno, mobilna mreža, mobilni operater, bežično, podaci, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"Wi-Fi, wi-fi, poziv, pozivanje"</string>
    <string name="keywords_display" msgid="874738809280751745">"zaslon, dodirni zaslon"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"zatamnjenje zaslona, dodirni zaslon, baterija, svijetlo"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"zatamnjenje zaslona, noć, nijansa, noćna smjena, svjetlina, boja zaslona, boja"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"pozadina, personalizirati, prilagoditi, zaslon"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"veličina teksta"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projicirati, emitirati, zrcaljenje zaslona, dijeljenje zaslona, zrcaljenje, dijeliti zaslon, emitiranje zaslona"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"prostor, disk, tvrdi disk, upotreba uređaja"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"potrošnja energije, punjenje"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"prikaz potrošnje baterije, potrošnja baterije, potrošnja energije"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"štednja baterije, štednja energije, štednja"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"preferencije za adaptivne značajke, adaptivna baterija"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pravopis, rječnik, provjera pravopisa, automatsko ispravljanje"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"prepoznavanje, unos, govor, govoriti, jezik, bez ruku, uvredljiva, riječ, audio, povijest, bluetooth slušalice"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"brzina, jezik, zadano, govoriti, govorenje, tekst u govor, pristupačnost, čitač zaslona, slijep"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"sat, vojni prikaz"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"poništavanje, vraćanje na zadano, vraćanje na tvorničke postavke, poništavanje"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"čišćenje, brisanje, oporavak, obrisati, uklanjanje, vraćanje na tvorničke postavke"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"pisač"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"zvučni signal zvučnika, zvučnik, glasnoća, utišano, tišina, zvuk, glazba, dodirne informacije, vibracija, vibriranje"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ne ometaj, prekinuti, prekid, zaustaviti"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"u blizini, lokacija, povijest, izvješćivanje, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"račun, dodavanje računa, poslovni profil, dodaj račun, ukloni, izbriši"</string>
    <string name="keywords_users" msgid="3497517660077620843">"ograničenje, ograničiti, ograničeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"ispravak teksta, ispraviti, zvuk, vibracija, automatski, jezik, pokret, predložiti, prijedlog, tema, uvredljivo, riječ, upisivati, emoji, međunarodno"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"poništavanje, vraćanje na zadano, postavke, zadano"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplikacije, preuzimanje, sustav"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikacije, dopuštenja, sigurnost"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikacije, zadano"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"zanemariti optimizacije, mirovanje, aplikacija u mirovanju"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"živopisno, RGB, sRGB, boja, prirodno, standardno"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, razlučivost, 1080 p, 1440 p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"temperatura, boja, D65, D73, bijela, žuta, plava, topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"kliziti prstom za otključavanje, zaporka, uzorak, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"prikačivanje zaslona"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"poslovni izazov, poslovni, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"poslovni profil, upravljani profil, objediniti, objedinjavanje, poslovni, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"pokreti"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"novčanik"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"plati, dodir, plaćanja"</string>
    <string name="keywords_backup" msgid="707735920706667685">"sigurnosno kopirati, sigurnosna kopija"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"pokret"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"otključavanje, lice, autentifikacija, prijava"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"lice, otključavanje, autentifikacija, prijava, otisak prsta, biometrijski"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"IMEI, MEID, min, verzija PRL-a, IMEI SV"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, vrsta mobilne mreže, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, vrsta mobilne mreže, roaming, EID"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, vrsta mobilne mreže, roaming, ICCID"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, vrsta mobilne mreže, roaming, ICCID, EID"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"EID"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serijski broj, verzija hardvera"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"razina Androidove sigurnosne zakrpe, verzija osnovnog frekvencijskog pojasa, verzija jezgre"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, svijetlo, tamno, način, osjetljivost na svjetlo, fotofobija, učiniti tamnijim, zatamniti, tamni način rada, migrena"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tamna tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"programska pogreška"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambijentalni zaslon, prikaz zaključanog zaslona"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"obavijest na zaključanom zaslonu, obavijesti"</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_biometric_settings" msgid="2173605297939326549">"lice, otisak prsta, dodati otisak prsta"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"otključavanje satom, dodati otključavanje satom"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"zatamnjenje zaslona, dodirni zaslon, baterija, pametna svjetlina, dinamična svjetlina, automatska svjetlina"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"pametno, zatamnjeni zaslon, mirovanje, baterija, vrijeme čekanja, pozornost, prikaz, zaslon, neaktivnost"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, pametno, automatski zakrenuti, automatsko zakretanje, zakrenuti, okrenuti, rotacija, portret, pejzaž, usmjerenje, okomito, vodoravno"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"nadogradnja, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, raspored, obavijesti, blokiranje, tišina, vibracija, mirovanje, rad, fokus, zvuk, utišano, dan, dan u tjednu, vikend, noć tijekom tjedna, događaj"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"zaslon, vrijeme zaključavanja, vrijeme čekanja, zaključan zaslon"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memorija, predmemorija, podaci, brisati, čistiti, slobodno, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"povezano, uređaj, slušalice, slušalice s mikrofonom, zvučnik, bežično, uparivanje, slušalice za umetanje u uho, glazba, medij"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"pozadina, tema, rešetka, prilagoditi, personalizirati"</string>
    <string name="keywords_styles" msgid="5291614313348476068">"ikona, isticanje, boja"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"zadano, pomoćno"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"plaćanje, zadano"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"dolazna obavijest"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb modemsko povezivanje, bluetooth modemsko povezivanje, wifi žarišna točka"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"taktilnost, vibriraj, vibracija"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"taktilnost, vibracija, zaslon, osjetljivost"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"taktilnost, vibracija, telefon, poziv, osjetljivost, zvono"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"taktilnost, vibracija, telefon, poziv, zvono, postupno"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"taktilnost, vibracija, osjetljivost, obavijest"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"taktilnost, vibracija, osjetljivost, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"taktilnost, vibracija, osjetljivost, mediji"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"taktilnost, vibriraj, vibracija"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"štednja baterije, ljepljiv, zadržati, štednja energije, baterija"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, raspored, štednja baterije, štednja energije, baterija, automatski, postotak"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, napredno pozivanje, 4g pozivanje"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, napredni pozivi, 5g pozivi"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"dodaj jezik, dodajte jezik"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"veličina teksta, velika slova, veliki font, veliki tekst, slabovidnost, povećati tekst, povećalo fonta, povećanje fonta"</string>
    <string name="keywords_always_show_time_info" msgid="645658129239452778">"uvijek uključen zaslon, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, oznaka, čitač"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Glasnoća, vibracija, Ne uznemiravaj"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Glasnoća medija"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Glasnoća emitiranja"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Glasnoća poziva"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Glasnoća alarma"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Glasnoća zvona i obavijesti"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Glasnoća zvona"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Glasnoća obavijesti"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Nedostupno jer je zvono utišano"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Melodija zvona telefona"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Zadani zvuk obavijesti"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvuk koji pruža aplikacija"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Zadani zvuk obavijesti"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Zadani zvuk alarma"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Najprije vibriraj, zatim postupno zvoni"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Prostorni zvuk"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonovi brojčanika"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvuk zaključavanja zaslona"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvukovi i vibracija punjenja"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvukovi priključivanja"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Zvukovi dodirivanja"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Uvijek prikazuj ikonu u načinu vibracije"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Priključna stanica reproducira"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Sve zvukove"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Samo medijske zvukove"</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či zvukove"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Automatski titlovi"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatski titlovi za medije"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Zvučnik telefona"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Žičane slušalice"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Zvuk s kompatibilnih medija postaje realističniji"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Isključeno"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Uključeno/<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Uključeno / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> i <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Možete uključiti prostorni zvuk i za Bluetooth uređaje."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Postavke povezanih uređaja"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Nijedan}=1{Postavljen je jedan raspored}one{Postavljen je # raspored}few{Postavljena su # rasporeda}other{Postavljeno je # rasporeda}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ne uznemiravaj"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Primajte obavijesti samo od važnih osoba i aplikacija"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Ograničavanje prekida"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Uključite opciju Ne uznemiravaj."</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Zvukovi alarma i medija mogu prekidati"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Rasporedi"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Brisanje rasporeda"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Brisanje"</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 Ne uznemiravaj"</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">"Dopusti ometanja koja proizvode zvuk"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokiranje vizualnih ometanja"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Dopusti vizualne signale"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opcije prikaza za skrivene obavijesti"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kad je uključena značajka Ne uznemiravaj"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Bez zvuka obavijesti"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Vidjet ćete obavijesti na zaslonu"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Kada obavijesti stignu, telefon neće davati zvučne signale niti vibrirati."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Bez vizualnih i zvučnih signala obavijesti"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Obavijesti se neće prikazivati niti će se čuti zvučni signali"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Telefon neće prikazati nove ni postojeće obavijesti niti će za njih vibrirati i zvoniti. No ključne obavijesti koje se odnose na aktivnost i status uređaja i dalje će se prikazivati.\n\nKada isključite način Ne uznemiravaj, propuštene obavijesti pronaći ćete tako da prijeđete od vrha zaslona 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">"Bez zvuka obavijesti"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Djelomično skriveno"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Bez vizualnih i zvučnih signala obavijesti"</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">"Kad je zaslon uključen"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kad je zaslon 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">"Ne uključuj zaslon"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ne upotrebljavaj treperenje svjetla"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ne prikazuj obavijesti na zaslonu"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Sakrij ikone trake statusa pri vrhu zaslona"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Sakrij točke obavijesti na ikonama aplikacija"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ne aktiviraj za obavijesti"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Ne prikazuj na zaslonu obavijesti"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikad"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kad je zaslon isključen"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kad je zaslon 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 vizualni znakovi obavijesti"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvuk, vibracija i vizualni znakovi obavijesti"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Obavijesti potrebne za osnovne aktivnosti i status uređaja nikad se neće skrivati."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Ništa"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"ostale 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">"Odmah isključi"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Način Ne uznemiravaj uključen je do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Način Ne uznemiravaj ostat će uključen dok ga ne isključite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Raspored <xliff:g id="RULE_NAME">%s</xliff:g> automatski je uključio Ne uznemiravaj"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Način Ne uznemiravaj automatski je 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 Ne uznemiravaj uključen je za <xliff:g id="RULE_NAMES">%s</xliff:g> uz prilagođene postavke."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Pregledajte prilagođene postavke"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Samo prioritetno"</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/jedan raspored može se uključiti automatski}one{Isključeno/# raspored može se uključiti automatski}few{Isključeno/# rasporeda mogu se uključiti automatski}other{Isključeno/# rasporeda može se uključiti automatski}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Što može prekidati značajku Ne uznemiravaj"</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 za Brze postavke"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Općenito"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Kada je način Ne uznemiravaj uključen, zvučni signali i vibriranje bit će isključeni, osim za prethodno navedene stavke koje dopustite."</string>
    <string name="zen_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">"Shvaćam"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Obavijesti"</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 način Ne uznemiravaj uključen, zanemarit će se poruke, podsjetnici i događaji, osim prethodno navedenih stavki koje dopustite. Možete prilagoditi postavke poruka da bi vaša obitelj, prijatelji ili drugi kontakti mogli stupiti u kontakt s vama."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Gotovo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Postavke"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Bez vizualnih i zvučnih signala obavijesti"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Bez zvuka obavijesti"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Obavijesti se neće prikazivati niti će se čuti zvučni signali. Dopušteni su pozivi kontakata označenih zvjezdicom i ponovnih pozivatelja."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Trenutačna postavka)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Želite li promijeniti postavke obavijesti za način Ne uznemiravaj?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvukovi poslovnog profila"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Koristi zvukove osobnog profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Upotrebljavajte iste zvukove kao i vaš osobni profil"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Melodija zvona poslovnog telefona"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Zadani zvuk poslovne obavijesti"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Zadani zvuk poslovnog alarma"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Isto kao osobni profil"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Želite li upotrebljavati zvukove osobnog profila?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Potvrdi"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Vaš poslovni profil upotrebljavat će iste zvukove kao i osobni profil"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Obavijesti"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Povijest obavijesti, razgovori"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Razgovor"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Upravljanje"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Obavijesti aplikacija"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Upravljajte obavijestima pojedinačnih aplikacija"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Općenito"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Obavijesti poslovnog profila"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Poslovni profil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prilagodljiv prioritet obavijesti"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Obavijesti nižeg prioriteta automatski se postavljaju na Neupadljivo"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Prilagodljiv poredak obavijesti"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automatski poredaj obavijesti prema važnosti"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Povratne informacije o prilagodljivim obavijestima"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Navedi prilagodbe obavijesti i prikaži opciju pružanja povratnih informacija sustavu"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Vraćanje važnosti obavijesti na zadano"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Postavke važnosti koje je korisnik promijenio vratite na zadane i dopustite pomoćniku za obavijesti da 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 prikaži predložene radnje i odgovore"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Pregledajte nedavne i odgođene obavijesti"</string>
    <string name="notification_history" msgid="8663811361243456201">"Povijest obavijesti"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Koristi povijest obavijesti"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Povijest obavijesti je isključena"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Uključite povijest obavijesti da biste vidjeli nedavne i odgođene obavijesti"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nema nedavnih obavijesti"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Ovdje će se prikazati vaše nedavne i odgođene obavijesti"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"prikaz postavki obavijesti"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"otvaranje obavijesti"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Dopusti odgodu obavijesti"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Točka obavijesti na ikoni aplikacije"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Oblačići"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Oblačići"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Prikaži ovaj razgovor u oblačiću"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Prikazuje pomičnu ikonu povrh aplikacija"</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">"Uključivanjem oblačića za ovu aplikaciju uključit će se i oblačići za vaš uređaj.\n\nTo utječe na druge aplikacije ili razgovore kojima je dopušteno 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">"Odustani"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Uključeno / Razgovori se mogu prikazivati kao pomične ikone"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Dopusti aplikacijama prikaz oblačića"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Neki razgovori prikazivat će se kao pomične ikone povrh drugih aplikacija"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Svi razgovori mogu se prikazivati u oblačiću"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Odabrani razgovori mogu se prikazivati u oblačiću"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Ništa se ne prikazuje u oblačiću"</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 mogu otvoriti oblačić osim"</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_ltr" msgid="5137180130142633085">"Prijeđite prstom udesno da biste odbacili izbornik, a ulijevo da biste ga prikazali"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Prijeđite prstom ulijevo da biste odbacili izbornik, a udesno da biste ga prikazali"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Sakrij bešumne obavijesti na traci statusa"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Trepereće svjetlo"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privatnost"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Preskakanje zaključanog zaslona"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Nakon otključavanja otvara se posljednji korišteni zaslon. Obavijesti se neće prikazivati na zaključanom zaslonu. Prijeđite prstom prema dolje za prikaz."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Zaključan zaslon, preskakanje, zaobilaženje"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kad je poslovni profil zaključan"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Prikazuj samo nove obavijesti na zaključanom zaslonu"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Automatsko uklanjanje prethodno pregledanih obavijesti sa zaključanog zaslona"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Obavijesti na zaklj. zaslonu"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Prikaži razgovore, zadane i bešumne"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Prikaži razgovore, zadane i bešumne"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Sakrij bešumne razgovore i obavijesti"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ne prikazuj obavijesti"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Osjetljive obavijesti"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Prikaži osjetljiv sadržaj kad je zaslon zaključan"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Osjetljive obavijesti poslovnog profila"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Prikaži osjetljiv sadržaj poslovnog profila kad je zaslon zaključan"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Prikaži cijeli sadržaj obavijesti"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Prikaži osjetljiv sadržaj samo kad je uređaj otključan"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Uopće ne prikazuj obavijesti"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Što želite da se prikazuje na zaključanom zaslonu?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Zaključan zaslon"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Prikaži cijeli sadržaj obavijesti poslovnog profila"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Sakrij osjetljiv sadržaj s posla"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kako želite da se prikazuju obavijesti profila kada je uređaj zaključan?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Obavijesti profila"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Obavijesti"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Obavijesti aplikacija"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategorija obavijesti"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Ponašanje"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Razgovori"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Odjeljak razgovora"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Dopusti aplikaciji upotrebu odjeljka razgovora"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nije razgovor"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Uklanjanje iz odjeljka razgovora"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Ovo je razgovor"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Dodavanje u odjeljak razgovora"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nema nijednog prioritetnog razgovora"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioritetni razgovor}one{# prioritetni razgovor}few{# prioritetna razgovora}other{# prioritetnih razgovora}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioritetni razgovori"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Prikazuju se pri vrhu odjeljka razgovora kao pomični oblačići"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Prikazuje se pri vrhu odjeljka razgovora"</string>
    <string name="other_conversations" msgid="551178916855139870">"Razgovori koji nisu prioritetni"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Razgovori koje ste izmijenili"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nedavni razgovori"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Izbriši nedavne razgovore"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Nedavni razgovori uklonjeni"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Razgovor uklonjen"</string>
    <string name="clear" msgid="5092178335409471100">"Izbriši"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Ovdje će se prikazivati prioritetni i izmijenjeni razgovori"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Ovdje će se prikazivati razgovori koje označite kao prioritetne ili razgovori u koje unesete bilo kakve izmjene. \n\nDa biste promijenili postavke razgovora: \nprijeđite prstom od vrha zaslona prema dolje kako bi se otvorio zaslon obavijesti, a zatim dodirnite razgovor i zadržite pritisak."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimiziraj"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Prikaži na zaslonu"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Bešumno"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Zadano"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Dopusti ometanja"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Aplikacija može emitirati zvuk, vibrirati i/ili prikazivati obavijesti na zaslonu"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritetno"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Prikazuje se pri vrhu odjeljka razgovora kao pomični oblačić i prikazuje profilnu sliku na zaključanom zaslonu"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> ne podržava većinu značajki razgovora. Ne možete postaviti razgovor kao prioritet i razgovori se neće prikazivati kao pomični oblačići."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Na zaslonu obavijesti sažmi obavijesti u jedan redak"</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 prikazuje se pri dnu odjeljka razgovora"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Možda će zvoniti ili vibrirati, ovisno o postavkama telefona"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kad je uređaj otključan, prikaži obavijesti kao natpis pri vrhu zaslona"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Sve obavijesti aplikacije \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Sve obavijesti aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Približno # obavijest dnevno}one{Približno # obavijest dnevno}few{Približno # obavijesti dnevno}other{Približno # obavijesti dnevno}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Približno # obavijest tjedno}one{Približno # obavijest tjedno}few{Približno # obavijesti tjedno}other{Približno # obavijesti tjedno}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikada"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Obavijesti na uređaju i u aplikacijama"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Odredite koje aplikacije i uređaji mogu čitati obavijesti"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Blokiran je pristup obavijestima poslovnog profila"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Poboljšane obavijesti"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Primajte prijedloge za radnje, odgovore i drugo"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Nema"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Nijedna instalirana aplikacija nije zatražila pristup obavijestima."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Dopusti pristup obavijestima"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"U Androidu 12 poboljšane obavijesti zamjenjuju prilagodljive obavijesti za Android. Ta značajka prikazuje predložene radnje i odgovore te organizira vaše obavijesti. \n\nPoboljšane obavijesti mogu pristupati sadržaju obavijesti, uključujući osobne podatke kao što su imena kontakata i poruke. Ta značajka može i odbacivati obavijesti ili poduzimati radnje u vezi s njima, na primjer može odgovarati na telefonske pozive i upravljati značajkom Ne uznemiravaj."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Želite li usluzi <xliff:g id="SERVICE">%1$s</xliff:g> dopustiti da pristupa obavijestima?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Aplikacija <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> moći će čitati sve obavijesti, uključujući osobne podatke, na primjer imena kontakata, fotografije i tekstove poruka koje primate. Aplikacija će moći i odgoditi ili odbaciti obavijesti ili poduzeti radnje povezane s gumbima u obavijestima, uključujući odgovaranje na telefonske pozive. \n\nAplikacija će također moći uključiti ili isključiti značajku Ne uznemiravaj i promijeniti povezane postavke."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Aplikaciji <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> omogućit će se:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Čitanje vaših poruka"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Može čitati vaše obavijesti, uključujući osobne podatke kao što su kontakti, poruke i fotografije."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Odgovaranje na poruke"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Može odgovarati na poruke i poduzimati radnje povezane s gumbima u obavijestima, uključujući odgađanje alarma, odbacivanje obavijesti i odgovaranje na pozive."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Promjena postavki"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Može uključiti ili isključiti značajku Ne uznemiravaj i promijeniti povezane postavke."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Ako isključite pristup obavijestima za <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, možda će se isključiti i pristup značajci Ne uznemiravaj."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Isključi"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Odustani"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"U stvarnom vremenu"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Tekuća komunikacija iz aplikacija koje se upotrebljavaju, navigacije, telefonskih poziva i ostalog"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Razgovori"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, tekstne poruke ili druge poruke"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Obavijesti"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Možda će zvoniti ili vibrirati, ovisno o postavkama"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Bešumno"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Obavijesti koje su uvijek bez zvuka i vibracija"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Dopušteno"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nije dopušteno"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Pogledajte sve aplikacije"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Promijenite postavke za sve aplikacije koje šalju obavijesti"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplikacije koje se prikazuju na uređaju"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Ta aplikacija ne podržava napredne postavke"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Više postavki"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Više postavki dostupno je unutar aplikacije"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Pomoćne usluge za virtualnu stvarnost"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nijedna instalirana aplikacija nije zatražila pokretanje kao pomoćna usluga za virtualnu stvarnost."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Želite li dopustiti pristup usluge virtualne stvarnosti za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"Usluga <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> moći će se pokrenuti kada budete upotrebljavali aplikacije u načinu rada virtualne stvarnosti."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Kada je uređaj u VR-u"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Smanji zamućenje (preporučeno)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Smanji treperenje"</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 slike u slici"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"slika u slici"</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">"Dopusti sliku u slici"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Dopustite toj aplikaciji da izradi prozor sa slikom u slici dok je otvorena ili kad izađete iz nje (npr. da biste nastavili gledati videozapis). Taj se prozor prikazuje iznad drugih aplikacija koje upotrebljavate."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Povezane poslovne i osobne 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 aplikacije poslovne i osobne"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Povezano"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Poveži te aplikacije"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Povezane aplikacije dijele dopuštenja i mogu međusobno pristupati podacima."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Aplikacije povežite samo ako ste sigurni da neće dijeliti osobne podatke s IT administratorom."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"U bilo kojem trenutku možete prekinuti vezu aplikacija u postavkama privatnosti uređaja."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Želite li svoje osobne podatke povjeriti poslovnoj aplikaciji <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Aplikacije povežite samo ako ste sigurni da neće dijeliti osobne podatke s 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 pristupati podacima u vašoj osobnoj aplikaciji <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Dopuštenja"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Ova aplikacija može upotrebljavati dopuštenja odobrena vašoj osobnoj aplikaciji <xliff:g id="NAME">%1$s</xliff:g>, primjerice pristup lokaciji, pohrani ili kontaktima."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nema povezanih aplikacija"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{Povezana je # aplikacija}one{Povezana je # aplikacija}few{Povezane su # aplikacije}other{Povezano je # aplikacija}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Da biste povezali te aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na svoj poslovni profil"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Da biste povezali te aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na svoj osobni profil"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Dodirnite da biste preuzeli aplikaciju"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Pristup opciji Ne uznemiravaj"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Dopusti opciju Ne uznemiravaj"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nijedna instalirana aplikacija nije zatražila pristup opciji Ne uznemiravaj"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Niste dopustili obavijesti te aplikacije"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Android na vaš zahtjev blokira prikazivanje te kategorije obavijesti na ovom uređaju"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Android na vaš zahtjev blokira prikazivanje te grupe obavijesti na ovom uređaju"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Ova aplikacija ne šalje obavijesti"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorije"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Drugo"</string>
    <string name="no_channels" msgid="4716199078612071915">"Ova aplikacija nije objavila nijednu obavijest"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Dodatne postavke u aplikaciji"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{Izbrisana je # kategorija}one{Izbrisana je # kategorija}few{Izbrisane su # kategorije}other{Izbrisano je # kategorija}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokiraj sve"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Nikad ne prikazuj te obavijesti"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Prikaži obavijesti"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nikad ne prikazuj obavijesti na zaslonu obavijesti ili na perifernim uređajima"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Dopusti točku obavijesti"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Prikaži točku obavijesti"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Nadjačaj Ne uznemiravaj"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Dopusti da se obavijesti nastave prikazivati kada je uključen način rada Ne uznemiravaj"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Zaključan zaslon"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Gotovo"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Trepereć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="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 već se upotrebljava"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Dodajte više"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Dodajte raspored događaja"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Dodajte vremenski raspored"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Odaberite vrstu rasporeda"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Želite li 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_app_set_behavior" msgid="4319517270279704677">"Te se postavke trenutačno ne mogu promijeniti. Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> automatski je uključila način Ne uznemiravaj s prilagođenim ponašanjem."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Te se postavke trenutačno ne mogu promijeniti. Neka je aplikacija automatski uključila način Ne uznemiravaj s prilagođenim ponašanjem."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Te se postavke trenutačno ne mogu promijeniti. Način Ne uznemiravaj ručno je uključen s prilagođenim ponašanjem."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Vrijeme"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Događaj"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Tijekom događaja za"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Bilo koji kalendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Kada je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Da, Možda ili Nema 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čeno/<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">"Ništa"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarm može nadjačati vrijeme završetka"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Raspored se isključuje kad se oglasi alarm"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Način Ne uznemiravaj"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Upotrijebi zadane postavke"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Izradi prilagođene postavke za ovaj raspored"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Za \"<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="zen_mode_conversations_title" msgid="5491912973456026379">"Razgovori"</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_important_conversations_second" msgid="7588299891972136599">"prioritetni razgovori"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Ništa"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Nijedan}=1{1 razgovor}one{# razgovor}few{# razgovora}other{# razgovora}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Tko može prekidati"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Čak i ako vas aplikacije za slanje poruka ili pozivanje ne mogu obavijestiti, osobe koje odaberete ovdje i dalje mogu stupiti u kontakt s vama putem tih aplikacija"</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 mogu prekidati"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Da biste bili sigurni da će se dopušteni pozivi čuti, provjerite je li uređaj postavljen na zvonjenje"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\" dolazni su pozivi blokirani. Možete prilagoditi postavke da bi vaša obitelj, prijatelji ili drugi kontakti mogli stupiti u kontakt s vama."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontakti označeni zvjezdicom"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Nijedan}=1{{contact_1}}=2{{contact_1} i {contact_2}}=3{{contact_1}, {contact_2} i {contact_3}}one{{contact_1}, {contact_2} i njih još #}few{{contact_1}, {contact_2} i njih još #}other{{contact_1}, {contact_2} i njih još #}}"</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 mogu prekidati"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Da biste bili sigurni da će se dopuštene poruke čuti, provjerite je li uređaj postavljen na zvonjenje"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\" dolazne su poruke blokirane. Možete prilagoditi postavke da bi vaša obitelj, prijatelji ili drugi kontakti mogli stupiti u kontakt s vama."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Dostupni ste za sve poruke"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Dostupni ste za sve pozive"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Nijedan}=1{1 kontakt}one{# kontakt}few{# kontakta}other{# kontakata}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Svatko"</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_mode_none_calls" msgid="2047166006414016327">"Nitko"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Nitko"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmi"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Alarmi odbrojavanja, sata, sigurnosnih sustava 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 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 dodirivanja"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvukovi tipkovnice i drugih gumba"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvukovi dodirivanja"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Zvukovi dodirivanja"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Podsjetnici"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Obavijesti 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 iz Kalendara"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Obavijesti o nadolazećim događajima 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">"Dopusti aplikacijama da nadjačaju"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikacije koje mogu prekidati"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Odaberite više aplikacija"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Aplikacije nisu odabrane"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nijedna aplikacija ne može prekidati"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Dodajte aplikacije"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Sve obavijesti"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Neke obavijesti"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Odabrane osobe i dalje vam se mogu obratiti, čak i ako aplikacijama ne dopustite da prekidaju"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Nijedna aplikacija ne može prekidati}=1{{app_1} može prekidati}=2{{app_1} i {app_2} mogu prekidati}=3{{app_1}, {app_2} i {app_3} mogu prekidati}one{{app_1}, {app_2} i još # aplikacija mogu prekidati}few{{app_1}, {app_2} i još # aplikacije mogu prekidati}other{{app_1}, {app_2} i još # aplikacija mogu prekidati}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikacije"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Obavijesti koje mogu prekidati"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Dopusti sve obavijesti"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Ništa ne može prekidati}=1{{sound_category_1} može prekidati}=2{{sound_category_1} i {sound_category_2} mogu prekidati}=3{{sound_category_1}, {sound_category_2} i {sound_category_3} mogu prekidati}one{{sound_category_1}, {sound_category_2} i još # zvuk mogu prekidati}few{{sound_category_1}, {sound_category_2} i još # zvuka mogu prekidati}other{{sound_category_1}, {sound_category_2} i još # zvukova mogu prekidati}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Ništa ne može prekidati"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Nitko ne može prekidati"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Neke osobe mogu prekidati"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Sve osobe mogu prekidati"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Uzastopni pozivi"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Dopusti ponovne pozivatelje"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"svi"</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">"ponovni pozivatelji"</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 nazove drugi put unutar <xliff:g id="MINUTES">%d</xliff:g> min"</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ćeg dana"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Promijeni na \"Samo alarmi\" na neodređeno vrijeme"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Promijeni na opciju Samo alarmi na jednu minutu do {time}}one{Promijeni na opciju Samo alarmi na # minutu do {time}}few{Promijeni na opciju Samo alarmi na # minute do {time}}other{Promijeni na opciju Samo alarmi na # minuta do {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Promijeni na opciju Samo alarmi na jedan sat do {time}}one{Promijeni na opciju Samo alarmi na # sat do {time}}few{Promijeni na opciju Samo alarmi na # sata do {time}}other{Promijeni na opciju Samo alarmi na # sati do {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Promijeni na \"Samo alarmi\" do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Promijeni na \"Uvijek prekidaj\""</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Upozorenje"</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">"Unesite 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="nfc_setting_on" msgid="7701896496026725772">"Uključeno"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Isključeno"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Uključeno"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Isključeno"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Prikvačivanje aplikacije"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Prikvačivanje aplikacije omogućuje da vaša trenutačna aplikacija bude vidljiva dok je ne otkvačite. Tu značajku možete koristiti kako biste, na primjer, prijatelju kojem vjerujete dopustili da igra određenu igru."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Kad je aplikacija prikvačena, može otvarati druge aplikacije i osobni podaci mogu biti dostupni. \n\nKako upotrebljavati prikvačivanje aplikacije: 	\n1. Uključite prikvačivanje aplikacije. 	\n2. Otvorite Pregled. 	\n3. Dodirnite ikonu aplikacije pri vrhu zaslona, a potom dodirnite Prikvači."</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Kad je aplikacija prikvačena, može otvarati druge aplikacije i osobni podaci mogu biti dostupni. \n\nAko želite s nekim sigurno dijeliti svoj uređaj, pokušajte koristiti profil gosta. \n\nKako upotrebljavati prikvačivanje aplikacije: 	\n1. Uključite prikvačivanje aplikacije. 	\n2. Otvorite Pregled. 	\n3. Dodirnite ikonu aplikacije pri vrhu zaslona, a potom dodirnite Prikvači."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kad je aplikacija prikvačena: \n\n•		osobni podaci mogu biti dostupni \n		(primjerice, kontakti i sadržaj e-pošte) \n•		prikvačena aplikacija može otvarati druge aplikacije \n\nPrikvačivanje aplikacije koristite samo s osobama kojima vjerujete."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Traži uzorak za otključavanje radi otkvačivanja"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Traži PIN radi otkvačivanja"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Traži zaporku radi otkvačivanja"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Zaključaj uređaj prilikom otkvačivanja"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Potvrdite brisanje SIM-a"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Potvrdite svoj identitet da biste mogli izbrisati eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Napredna zaštita memorije beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Napredna zaštita memorije"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Ova beta značajka pomaže vam zaštititi uređaj od programskih pogrešaka koje ugrožavaju sigurnost."</string>
    <string name="memtag_on" msgid="824938319141503923">"Uključeno"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Isključeno"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Uključeno nakon ponovnog pokretanja"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Isključeno nakon ponovnog pokretanja"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Trenutačno nedostupno za vaš uređaj"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Uvijek uključeno za vaš uređaj"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Morat ćete ponovo pokrenuti uređaj da biste uključili ili isključili naprednu zaštitu memorije. Kad je uključena, uređaj može raditi sporije."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Želite li ponovo pokrenuti uređaj?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Trebat ćete ponovo pokrenuti uređaj da biste uključili naprednu zaštitu memorije."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Trebat ćete ponovo pokrenuti uređaj da biste isključili naprednu zaštitu memorije."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Pokreni ponovo"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Ne sad"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Saznajte više o naprednoj zaštiti memorije."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Ovim poslovnim profilom upravlja:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Upravlja <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Otvaranje prema zadanim postavkama"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Otvori podržane veze"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Dopustite otvaranje web-veza u ovoj aplikaciji"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Veze koje se otvaraju u ovoj aplikaciji"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podržane veze"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Ostale zadane postavke"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Dodajte vezu"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Aplikacija može potvrditi veze tako da se automatski otvaraju u aplikaciji."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# potvrđena veza}one{# potvrđena veza}few{# potvrđene veze}other{# potvrđenih veza}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Ova je veza potvrđena i automatski se otvara u ovoj aplikaciji.}one{Ove su veze potvrđene i automatski se otvaraju u ovoj aplikaciji.}few{Ove su veze potvrđene i automatski se otvaraju u ovoj aplikaciji.}other{Ove su veze potvrđene i automatski se otvaraju u ovoj aplikaciji.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"U redu"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Prikaži popis potvrđenih veza"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Traženje drugih podržanih veza…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Odustani"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# podržana veza}one{# podržana veza}few{# podržane veze}other{# podržanih veza}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Dodaj"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Otvara se u aplikaciji <xliff:g id="APP_LABEL">%s</xliff:g>"</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">"interna pohrana"</string>
    <string name="storage_type_external" msgid="125078274000280821">"vanjska pohrana"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> potrošeno od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Upotrijebljena pohrana"</string>
    <string name="change" msgid="273206077375322595">"Promijeni"</string>
    <string name="change_storage" msgid="8773820275624113401">"Promijeni pohranu"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Obavijesti"</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_categories_off" msgid="7712037485557237328">"{count,plural, =1{Isključena je # kategorija}one{Isključena je # kategorija}few{Isključene su # kategorije}other{Isključeno je # kategorija}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# dodatno dopuštenje}one{# dodatno dopuštenje}few{# dodatna dopuštenja}other{# dodatnih dopuštenja}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nije odobreno nijedno dopuštenje"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nije zatraženo nijedno dopuštenje"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Upravljajte pristupom aplikacija svojim podacima"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Nadzorna ploča za privatnost"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Prikaži aplikacije koje su nedavno upotrebljavale dopuštenja"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Nekorištene aplikacije"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# nekorištena aplikacija}one{# nekorištena aplikacija}few{# nekorištene aplikacije}other{# nekorištenih aplikacija}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Postavke nekorištenih aplikacija"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pauziraj aktivnosti u aplikacijama ako se ne koriste"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Uklanjaju se dopuštenja, brišu privremene datoteke i zaustavljaju obavijesti"</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_blocked_apps" msgid="1065653868850012325">"Isključeno"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Dodatne postavke"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Upravitelj dopuštenja"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Ažuriranja o dijeljenju podataka za lokaciju"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Pregledajte aplikacije koje su promijenile način na koji mogu dijeliti vaše podatke o lokaciji"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Dodirnite za aktivaciju"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dvaput dodirnite bilo gdje na zaslonu da biste aktivirali uređaj"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Otvaranje veza"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ne otvaraj podržane veze"</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="app_link_open_always" msgid="9167065494930657503">"Dopusti aplikaciji da otvara podržane veze"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Pitaj svaki put"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Aplikaciji nije dopušteno da otvara veze"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplikacija polaže prava na obradu # veze}one{Aplikacija polaže prava na obradu # veze}few{Aplikacija polaže prava na obradu # veze}other{Aplikacija polaže prava na obradu # veza}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikacija polaže prava na obradu sljedećih veza:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Pomoćnik i glasovni unos"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Apl. digitalnog asistenta"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Zadana apl. digital. asistenta"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Slažem se"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Preglednik"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikacija za pozive"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sustav)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Pohrana aplikacija"</string>
    <string name="usage_access" msgid="5487993885373893282">"Pristup upotrebi"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Dopusti pristup upotrebi"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Vrijeme upotrebe"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Pristup upotrebi omogućuje aplikaciji praćenje drugih aplikacija koje upotrebljavate i učestalosti njihove upotrebe, kao i praćenje mobilnog operatera, postavki jezika i ostalih pojedinosti."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memorija"</string>
    <string name="always_running" msgid="9012705720688200252">"Uvijek se izvodi (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Ponekad se izvodi (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Rijetko se izvodi (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</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="high_power_apps" msgid="5623152700992102510">"Optimizacija baterije"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Nije optimizirano"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Nije optimizirano"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimiziranje potrošnje baterije"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimizacija baterije nije dostupna"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Želite li dopustiti da aplikacija uvijek radi u pozadini?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Ako dopustite da <xliff:g id="APP_NAME">%1$s</xliff:g> uvijek radi u pozadini, to može ubrzati trošenje baterije. \n\nTo možete promijeniti kasnije u odjeljku Postavke &gt; Aplikacije."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> potrošnje od posljednjeg potpunog punjenja"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> potrošnje u posljednja 24 h"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Nema potrošnje baterije od posljednjeg potpunog punjenja"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Želite li podijeliti izvješće o programskim pogreškama?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"IT administrator zatražio je izvješće o programskoj pogrešci radi lakšeg rješavanja problema na uređaju. Moguće je da će se aplikacije i podaci dijeliti."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"IT administrator zatražio je izvješće o programskoj pogrešci radi lakšeg rješavanja problema na uređaju. Moguće je da će se aplikacije i podaci dijeliti, što bi moglo privremeno usporiti uređaj."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Ovo izvješće o programskoj pogrešci dijeli se s vašim IT administratorom. Više pojedinosti možete saznati od te osobe."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Dijeli"</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_power_only" msgid="3408055485802114621">"Punjenje povezanog uređaja"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Prijenos datoteka"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Web-kamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konvertiraj videozapise u AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videozapisi će se reproducirati na više media playera, ali bi se kvaliteta mogla smanjiti"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Modemsko povezivanje USB-om"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Svrha upotrebe USB-a"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Zadana konfiguracija USB-a"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Te će se postavke primjenjivati kada je povezan drugi uređaj, a vaš je telefon otključan. Povežite se samo s pouzdanim uređajima."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Opcije napajanja"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opcije prijenosa datoteka"</string>
    <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 datoteka"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Modemsko povezivanje USB-om"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Web-kamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Prijenos datoteke i napajanje"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Modemsko povezivanje USB-om 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="usb_summary_UVC_power" msgid="226810354412154061">"Web-kamera i napajanje"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Provjera u pozadini"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Koristi tekst sa zaslona"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Dopustite aplikaciji pomoćnika da pristupi sadržaju zaslona kao tekstu"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Koristi snimku zaslona"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Dopustite aplikaciji pomoćnika da pristupi slici na zaslonu"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Bljeskanje zaslona"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Rubovi zaslona bljeskaju kada aplikacija pomoćnika pristupi tekstu sa zaslona ili snimke zaslona"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Aplikacije pomoćnika mogu vam pomoći na temelju podataka s prikazanog zaslona. Neke aplikacije podržavaju pokretač i usluge glasovnog unosa kako bi vam pružile integriranu pomoć."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Prosječna upotreba memorije"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimalna upotreba memorije"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Upotreba memorije"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Potrošnja aplikacije"</string>
    <string name="memory_details" msgid="6133226869214421347">"Pojedinosti"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Prosječna upotreba memorije u posljednja 3 sata: <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"U posljednja 3 sata nije bilo upotrebe memorije"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Razvrstaj po prosječnoj upotrebi"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Razvrstaj po maksimalnoj upotrebi"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Izvedba"</string>
    <string name="total_memory" msgid="5244174393008910567">"Ukupna memorija"</string>
    <string name="average_used" msgid="690235917394070169">"Prosječna upotreba (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Dostupno"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memorija koju upotrebljavaju aplikacije"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{Jedna aplikacija upotrijebila je memoriju u posljednjih {time}}one{# aplikacija upotrijebila je memoriju u posljednjih {time}}few{# aplikacije upotrijebile su memoriju u posljednjih {time}}other{# aplikacija upotrijebilo je memoriju u posljednjih {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Učestalost"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimalna upotreba"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Nema upotrebe podataka"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Želite li aplikaciji <xliff:g id="APP">%1$s</xliff:g> dopustiti pristup značajci Ne uznemiravaj?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikacija će moći uključiti ili isključiti opciju Ne uznemiravaj i mijenjati povezane postavke."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Mora ostati uključeno jer je uključen pristup obavijestima"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Želite li opozvati pristup značajci Ne uznemiravaj za aplikaciju <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Uklonit će se sva pravila Ne uznemiravaj koja je postavila ova aplikacija."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ne optimiziraj"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizacija"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Baterija se može brže isprazniti. Aplikacijama više neće biti ograničeno korištenje pozadinske baterije."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Preporučuje se za dulje trajanje baterije"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Ništa"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Isključivanje pristupa upotrebi za tu aplikaciju ne sprječava administratora da prati upotrebu podataka za aplikacije na vašem radnom profilu."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Prikaz iznad drugih aplikacija"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Prikaz iznad drugih aplikacija"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Dopusti prikaz iznad drugih aplikacija"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Dopustite toj aplikaciji da se prikazuje iznad drugih aplikacija koje upotrebljavate. Aplikacija će moći vidjeti gdje ste dodirnuli ili promijeniti sadržaj zaslona."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Pristup svim datotekama"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Dopusti pristup za upravljanje svim datot."</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Dopustite toj aplikaciji čitanje, izmjenu i brisanje svih datoteka na ovom uređaju ili drugim povezanim uređajima za pohranu. Ako date to dopuštenje, aplikacija može pristupati datotekama bez vašeg znanja."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Može pristupiti svim datotekama"</string>
    <string name="full_screen_intent_title" msgid="1068024949389956404">"Upravljanje prikazom na cijelom zaslonu"</string>
    <string name="permit_full_screen_intent" msgid="2251949245519201421">"Omogući aplikacijama prikaz obavijesti preko cijelog zaslona"</string>
    <string name="footer_description_full_screen_intent" msgid="8322826300555418227">"Omogućite aplikaciji da prikazuje obavijesti koje prekrivaju cijeli zaslon."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplikacije za upravljanje medijima"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Dopusti aplikaciji upravljanje medijima"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Ako je dopušteno, ta aplikacija može mijenjati ili brisati medijske datoteke izrađene putem ostalih aplikacija bez vašeg dopuštenja. Aplikacija mora imati dopuštenje za pristup datotekama i medijima."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Mediji, datoteka, upravljanje, upravitelj, upravljati, urediti, uređivač, aplikacija, program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr slušatelj virtualne stvarnosti stereo pomoćna usluga"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Prikaz iznad drugih aplikacija"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikacije s dopuštenjem"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Dopušteno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nije dopušteno"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalacija aplikacije nepoznati izvori"</string>
    <string name="write_settings" msgid="6864794401614425894">"Izmjena postavki sustava"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"pisanje izmjena postavki sustava"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Može instalirati druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"S dopuštenjem za izmjenu postavki sustava"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"S dopuštenjem za izmjenu postavki sustava"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Izmjena postavki sustava"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Dopusti izmjenu postavki sustava"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"To dopuštenje omogućuje aplikaciji izmjenu postavki sustava."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Dopusti iz ovog izvora"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Dvostruko obrtanje za fotoaparat"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Otvaranje aplikacije fotoaparata obrtanjem ručnog zgloba dvaput"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Veličina prikaza"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Povećajte ili smanjite sve"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"prikaz, gustoća, zumiranje zaslona, skalirati, skaliranje"</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="disconnected" msgid="3469373726996129247">"Nije povezano"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nije povezana"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Broj instaliranih aplikacija: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> iskorišteno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> slobodno"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tamna tema, veličina fonta, svjetlina"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Iskorišteno je prosječno <xliff:g id="USED_MEMORY">%1$s</xliff:g> od <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prijavljeni ste kao <xliff:g id="USER_NAME">%1$s</xliff:g>"</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="6852347040813204503">"Blokirano u skladu s poslovnim pravilima"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Glasnoća se ne može promijeniti"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Upućivanje poziva nije dopušteno"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Slanje SMS-ova nije dopušteno"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Upotreba fotoaparata nije dopuštena"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Izrada snimki zaslona nije dopuštena"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Aplikacija se ne može otvoriti"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokirao zajmodavac"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Potreban roditelj"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Predaj telefon roditelju za početak postavljanja"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Predaj telefon roditelju kako bi odobrio promjenu te postavke."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Za više informacija obratite se IT administratoru"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Više pojedinosti"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Vaš administrator može nadzirati aplikacije i postavke povezane s vašim radnim profilom, uključujući postavke, dopuštenja, korporacijski pristup, aktivnost na mreži i podatke o lokaciji uređaja, te njima upravljati."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Vaš administrator može nadzirati aplikacije i podatke povezane s tim korisnikom, uključujući postavke, dopuštenja, korporacijski pristup, aktivnost na mreži i podatke o lokaciji uređaja, te njima upravljati."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Vaš administrator može nadzirati aplikacije i podatke povezane s ovim uređajem, uključujući postavke, dopuštenja, korporacijski pristup, aktivnost na mreži i podatke o lokaciji uređaja, te njima upravljati."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Administrator uređaja možda može pristupiti podacima povezanim s ovim uređajem, upravljati aplikacijama i promijeniti postavke 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">"Žarišna je točka aktivna"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Način rada u zrakoplovu uklj."</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Mreže nisu dostupne"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Način Ne uznemiravaj uključen"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Na telefonu je isključen zvuk"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Uz iznimke"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Štednja baterije je uključena"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Značajke su ograničene"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobilni su podaci isključeni"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet je dostupan samo putem Wi‑Fija"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Štednja podatkovnog prometa"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Značajke su ograničene"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Radni je profil isključen"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Za aplikacije i obavijesti"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Uključi zvuk"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Isključen je zvuk zvona"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Za pozive i obavijesti"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Samo vibracija"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Za pozive i obavijesti"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Postavite raspored Noćnog svjetla"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Automatski oboji zaslon svake noći"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Noćno je svjetlo uključeno"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Zaslon obojen žuto"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Nijanse sive"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Prikazuj samo u tonovima sive"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Sažmi"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Hladna temperatura boje"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Upotrebljavaj hladnije boje prikaza"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Da biste primijenili promjenu boje, isključite zaslon"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Laserski senzor fotoaparata"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatska ažuriranja sustava"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Primijeni ažuriranja pri ponovnom pokretanju uređaja"</string>
    <string name="usage" msgid="287782903846013936">"Potrošnja"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Potrošnja podatkovnog prometa"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Potrošnja podatkovnog prometa aplikacija"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Potrošnja putem Wi-Fija"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Prijenos podataka izvan mreže operatera"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Potrošnja ethernet podataka"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobilnih podataka"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> Wi-Fi 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 potrošnji i ograničenje"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciklus potrošnje podatkovnog prometa"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Upozori na <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Ograničenje podatkovnog prometa od <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Upozori na <xliff:g id="ID_1">^1</xliff:g>/Ograniči na <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Mobilni operater može obračunavati podatke na drugačiji način od uređaja"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Ne uključuje podatke koje koriste mreže mobilnog operatera"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Iskoristili ste <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Postavi upozorenje o potrošnji"</string>
    <string name="data_warning" msgid="2925054658166062884">"Upozorenje o potrošnji"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Upozorenje o potrošnji podatkovnog prometa i ograničenje podatkovnog prometa mjeri vaš uređaj. Ta se mjerenja mogu razlikovati od mjerenja vašeg mobilnog operatera."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Postavi ograničenje potrošnje"</string>
    <string name="data_limit" msgid="8731731657513652363">"Ograničenje 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">"Konfiguriraj"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Ostale aplikacije uključene u upotrebu"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{Jedna aplikacija smije upotrebljavati neograničene podatke kada je štednja podatkovnog prometa uključena}one{# aplikacija smije upotrebljavati neograničene podatke kada je štednja podatkovnog prometa uključena}few{# aplikacije smiju upotrebljavati neograničene podatke kada je štednja podatkovnog prometa uključena}other{# aplikacija smije upotrebljavati neograničene podatke kada je štednja podatkovnog prometa uključena}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primarni podaci"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Podaci putem Wi‑Fi-ja"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Iskorišteno: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Više od <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 podatakovnog prometa između <xliff:g id="START_DATE">%1$s</xliff:g> i <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Nema podataka za taj datumski raspon"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Preostao # dan}one{Preostao # dan}few{Preostalo # dana}other{Preostalo # dana}}"</string>
    <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 operater prije <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="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 operater <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Upravo je ažurirano"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Prikaži plan"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Prikaz pojedinosti"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Štednja podat. prometa"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neograničeni podaci"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Pozadinski su podaci 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 štednju podatkovnog prometa"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neograničena upotreba podataka"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Dopusti neograničen pristup podacima kada je uključena štednja podatkovnog prometa"</string>
    <string name="home_app" msgid="6056850504746902747">"Početna aplikacija"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Dodajte još jedan otisak prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Otključajte 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="app_battery_usage_title" msgid="346558380609793334">"Potrošnja baterije za aplikacije"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Postavite potrošnju baterije za aplikacije"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Neograničeno"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimizirano"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Ograničeno"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Zadana provjera pravopisa"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Odabir provjere pravopisa"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Upotreba provjere pravopisa"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nije odabrano"</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_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"značaj"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"objašnjenje"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"može prikazivati značku"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"namjera"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"namjera brisanja"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"namjera cijelog zaslona"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"radnje"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"naslov"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"daljinski ulazi"</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">"obavijest poslana"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Objekt rangiranja nedostaje."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Objekt rangiranja ne sadrži tu tipku."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Urez na zaslonu"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"obrezana slika za zaslon, 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 za aplikacije"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija može upotrebljavati neograničene podatke</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije mogu upotrebljavati neograničene podatke</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija može upotrebljavati neograničene podatke</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Prikaži više"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Dugački zadaci u pozadini"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Dopusti dugotrajne zadatke u pozadini"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Dugački zadaci u pozadini"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Dopustite ovoj aplikaciji izvođenje dugačkih zadataka u pozadini. To joj omogućuje izvođenje zadataka koji bi mogli potrajati dulje od nekoliko minuta, kao što su preuzimanja i prijenosi. \n\nAko se to dopuštenje odbije, sustav će ograničiti koliko dugo aplikacija može izvoditi takve zadatke u pozadini."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"dugački zadaci, prijenos podataka, zadaci u pozadini"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Poništi ograničavanje brzine ShortcutManagera"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Ograničavanje brzine ShortcutManagera poništeno je"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Odaberite što se prikazuje na zaključanom zaslonu"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Prikazivanje ili sakrivanje sadržaja obavijesti"</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 SMS-ovima s dodatnom naplatom"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"SMS-ovi s dodatnom naplatom mogu se dodatno naplaćivati i povećat će vaš račun. Ako nekoj aplikaciji date to dopuštenje, moći ćete slati SMS-ove s dodatnom naplatom pomoću te aplikacije."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Pristup SMS-ovima s dodatnom naplatom"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Isključeno"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Povezano s uređajem <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Povezano s više uređaja"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Demo način korisničkog sučelja sustava"</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 štednje baterije"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Privremeno onemogućeno zbog štednje baterije"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Isključi štednju baterije"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Trenutačno uključeno zbog Štednje baterije"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Isprobajte Tamnu temu"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pomaže produljiti trajanje baterije"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Pločice brzih postavki za razvojne programere"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Onemogući vrijeme čekanja za autorizacije za adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Onemogućite automatski opoziv autorizacija za adb za sustave koji se ne povežu u zadanom razdoblju (sedam dana) ili korisnički konfiguriranom razdoblju (najmanje jedan 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 poslovnog profila"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Traži kontakte iz poslovnog direktorija u osobnim aplikacijama"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Vaš IT administrator mogao bi vidjeti vaša pretraživanja i dolazne pozive"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendar za više profila"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Prikaži poslovne događaje na osobnom kalendaru"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Upravljanje pohranom"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Upravitelj pohrane uklanja fotografije i videozapise s uređaja za koje je napravljena sigurnosna kopija kako bi oslobodio prostor za pohranu."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Ukloni fotografije i videozapise"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Upravitelj pohrane"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Upotreba upravitelja pohrane"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Pokreti"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Brzo otvaranje fotoaparata"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Da biste brzo otvorili fotoaparat, dvaput pritisnite tipku za uključivanje/isključivanje. Funkcionira na svim zaslonima."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Promjena u selfie kameru trzajem"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Način navigacije"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigacija pomoću dva gumba"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Da biste promijenili aplikaciju, prijeđite prstom prema gore na početnom zaslonu. Da biste vidjeli sve aplikacije, ponovo prijeđite prstom prema gore. Da biste se vratili, dodirnite gumb Natrag."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Sigurnost i hitni slučajevi"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"SOS poziv, zdravstveni podaci, upozorenja"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigacija pokretima"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Da biste otvorili početni zaslon, prijeđite prstom od dna zaslona prema gore. Da biste promijenili aplikaciju, prijeđite prstom od dna prema gore, zadržite i otpustite. Da biste se vratili, prijeđite prstom od lijevog ili desnog ruba."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigacija pomoću tri gumba"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Za povratak, otvaranje početnog zaslona i promjenu aplikacije koristite se gumbima pri dnu zaslona."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigacija za sustav, navigacija pomoću dva gumba, navigacija pomoću tri gumba, navigacija pokretima, prelazak prstom"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitalni asistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Prijeđite prstom da biste pokrenuli asistenta"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Prijeđite prstom prema gore iz donjeg kuta da biste pokrenuli aplikaciju digitalnog asistenta."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Držite gumb početnog zaslona za Asistenta"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Pritisnite i držite gumb početnog zaslona da biste pokrenuli aplikaciju digitalnog asistenta."</string>
    <string name="low_label" msgid="6525629096999711220">"Niska"</string>
    <string name="high_label" msgid="357503396626018487">"Visoka"</string>
    <string name="left_edge" msgid="1513576842959071849">"Lijevi rub"</string>
    <string name="right_edge" msgid="1505309103265829121">"Desni rub"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Veća osjetljivost može utjecati na pokrete u aplikacijama uz rub zaslona."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Osjetljivost stražnje strane"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Osjetljivost navigacije pokretima"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigacija pomoću gumba"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigacija pokretima, osjetljivost pozadine, pozadinski pokret"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigacija, gumb početnog zaslona"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"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_mode_shortcut_title" msgid="1847871530184067369">"Prečac za način rada jednom rukom"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"dostupnost"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Prijeđite prstom prema dolje za"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Upotreba prečaca za sljedeće"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Povucite prema dolje gornju polovicu zaslona kako biste olakšali dosezanje jednom rukom"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Kako upotrebljavati način rada jednom rukom"</b>\n" • U postavkama navigacije sustava odaberite navigaciju pokretima.\n • Prijeđite prstom prema dolje blizu donjeg ruba zaslona."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Povlačenje zaslona da bude u dosegu"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Vrh zaslona pomaknut će se da ga možete dosegnuti palcem."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Prikaz obavijesti"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Pojavit će se obavijesti i postavke."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Da biste pogledali vrijeme, obavijesti i druge informacije, dvaput dodirnite zaslon."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Probudite zaslon"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Da biste pogledali vrijeme, obavijesti i druge informacije, dodirnite zaslon."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"SOS poziv"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Upotreba SOS poziva"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Najmanje pet puta brzo pritisnite tipku za uključivanje/isključivanje da biste pokrenuli radnje u nastavku"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Reprodukcija alarma odbrojavanja"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Reproduciraj glasan zvuk pri pokretanju SOS poziva"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Traženje pomoći"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Poziv upomoć"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Telefonski broj za pomoć"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Dotaknite za promjenu"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Ako unesete broj koji nije broj hitne službe:\n • Uređaj mora biti otključan da biste upotrijebili SOS poziv.\n • Možda vam se nitko neće javiti na poziv."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Prelazak prstom preko senzora za obavijesti"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Prelazak prstom preko senzora"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Brz pregled obavijesti"</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">"Početni program za pokretanje već je otključan"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Povežite se s internetom ili se obratite mobilnom operateru"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nije dostupno na uređajima koje je zaključao mob. operater"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Ponovo pokrenite uređaj da biste omogućili značajku zaštite uređaja."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Ukupno dostupno: <xliff:g id="SIZE">%1$s</xliff:g>\n\nPosljednji put pokrenuto <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant aplikacije"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Otvaraj veze u aplikacijama čak i ako te aplikacije nisu instalirane"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant aplikacije"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Postavke za instant aplikacije"</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 za korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automatski sinkroniziraj podatke aplikacija"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Dopustite aplikacijama da automatski osvježavaju podatke"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sinkronizacija računa"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinkronizacija uključena za <xliff:g id="ID_1">%1$d</xliff:g> od sljedećeg broja stavki: <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinkronizacija uključena za sve stavke"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinkronizacija isključena za sve stavke"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informacije 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 <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Da bi osigurala pristup vašim radnim podacima, vaša organizacija može promijeniti postavke i instalirati softver na vaš uređaj.\n\nViše pojedinosti zatražite od administratora svoje organizacije."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Vrste podataka koje može vidjeti vaša organizacija"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Izmjene koje je unio administrator 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 povezani s vašim radnim računom, na primjer e-pošta i kalendar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Popis aplikacija na vašem uređaju"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Utrošeno vrijeme i količina podataka u svakoj aplikaciji"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Najnoviji zapisnik mrežnog prometa"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Najnovije izvješće o programskoj pogrešci"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Najnoviji sigurnosni zapisnik"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Ništa"</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 procijenjen je i možda ne uključuje aplikacije koje su instalirane izvan Trgovine Play."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Najmanje # aplikacija}one{Najmanje # aplikacija}few{Najmanje # aplikacije}other{Najmanje # aplikacija}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Dopuštenja za lokaciju"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Dopuštenja za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Dopuštenja za fotoaparat"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Zadane aplikacije"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# aplikacija}one{# aplikacija}few{# aplikacije}other{# aplikacija}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Zadana tipkovnica"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Postavljeno na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Aktiviran je uvijek uključeni VPN"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Uvijek uključeni VPN aktiviran je u osobnom profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Uvijek uključeni VPN aktiviran je u radnom profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Postavljen je globalni HTTP proxy"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Pouzdane vjerodajnice"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Pouzdane vjerodajnice na vašem osobnom profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Pouzdane vjerodajnice na vašem radnom profilu"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Najmanje # CA certifikat}one{Najmanje # CA certifikat}few{Najmanje # CA certifikata}other{Najmanje # CA certifikata}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administrator može zaključati uređaj i poništiti zaporku"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administrator može izbrisati sve podatke na uređaju"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Broj neuspjelih pokušaja unosa zaporke prije brisanja svih podataka s uređaja"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Broj neuspjelih pokušaja unosa zaporke prije brisanja podataka s radnog profila"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# pokušaj}one{# pokušaj}few{# pokušaja}other{# pokušaja}}"</string>
    <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>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Ograničena postavka"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Ograničene postavke dopuštene su za aplikaciju <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Radi vaše sigurnosti ova je postavka trenutačno nedostupna."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informacije o uređaju na pretplatu"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Vaš vjerovnik može promijeniti postavke i instalirati softver na ovom uređaju tijekom postavljanja.\n\nAko propustite uplatu, vjerovnik može zaključati uređaj i promijeniti postavke.\n\nDa biste saznali više, obratite se vjerovniku."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Ako ste kupili uređaj na rate, nije vam dostupno sljedeće:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"instaliranje aplikacija koje nisu iz Trgovine Play"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"ponovno pokretanje uređaja u sigurnom načinu rada"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"dodavanje više korisnika na uređaj"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"promjena datuma, vremena i vremenske zone"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"upotreba opcija za razvojne programere"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Vašem operateru dostupno je sljedeće:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"pristup vašem IMEI broju"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"vraćanje uređaja na tvorničke postavke u slučaju pogreške"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Ako se uređaj zaključa, možete ga koristiti samo za sljedeće:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"upućivanje hitnih poziva"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"pregled podataka o sustavu kao što su datum, vrijeme, mrežni status i stanje baterije"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"uključivanje ili isključivanje uređaja"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"pregled obavijesti i tekstnih poruka"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"pristup aplikacijama koje dopušta operater"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Nakon što platite cijeli iznos:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"sva ograničenja se uklanjaju s uređaja"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"deinstaliranje aplikacije vjerovnika"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Aplikacija kamere}one{Aplikacija kamere}few{Aplikacije kamere}other{Aplikacija kamere}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikacija Kalendar"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikacija Kontakti"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Aplikacija klijenta e-pošte}one{Aplikacija klijenta e-pošte}few{Aplikacije klijenta e-pošte}other{Aplikacija klijenta e-pošte}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikacija Karta"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Aplikacija telefona}one{Aplikacija telefona}few{Aplikacije telefona}other{Aplikacija telefona}}"</string>
    <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_default_internal_storage" msgid="4055660218818688131">"Ovaj uređaj"</string>
    <string name="storage_games" msgid="1176568610086802469">"Igre"</string>
    <string name="storage_files" msgid="7968460921272772299">"Datoteke"</string>
    <string name="storage_images" msgid="2055893015567979387">"Slike"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videozapisi"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audiozapisi"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Aplikacije"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumenti i drugo"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sustav"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Otpad"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Želite li isprazniti otpad?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"U otpadu je ukupno <xliff:g id="TOTAL">%1$s</xliff:g> datoteka. Sve će se stavke izbrisati zauvijek i nećete ih moći vratiti."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Otpad je prazan"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Isprazni otpad"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Iskorišteno: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Ukupno <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Izbriši podatke aplikacije"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Želite li ukloniti tu instant aplikaciju?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Otvori"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Igre"</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">"Automatsko popunjavanje"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Zadana usluga automatskog popunjavanja"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Zaporke"</string>
    <string name="credman_credentials" msgid="7413302794874989255">"Usluge za zaporke, šifre i podatke"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# zaporka}one{# zaporka}few{# zaporke}other{# zaporki}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatsko, popunjavanje, automatsko popunjavanje, zaporka"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"podaci, šifra, zaporka"</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; upotrebljava sadržaj na zaslonu za procjenu onoga što se može automatski popuniti."</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Isključiti %1$s?"</string>
    <string name="credman_confirmation_message" msgid="3499478570809427026">"Spremljene informacije, poput adresa ili načina plaćanja neće se popunjavati kad se prijavite. Da bi se vaše spremljene informacije unijele, omogućite uslugu za zaporke, šifre i/ili podatke."</string>
    <!-- no translation found for credman_enable_confirmation_message_title (1037501792652277829) -->
    <skip />
    <!-- no translation found for credman_enable_confirmation_message (8407841892310870169) -->
    <skip />
    <string name="credman_error_message_title" msgid="4741457523969373713">"Ograničenje broja usluga za zaporke, šifre i podatke"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Istovremeno možete imati pet aktivnih usluga za zaporke, šifre i podatke. Isključite jednu uslugu da biste ih dodali još."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Isključi"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatsko popunjavanje"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Razina 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 skupova podataka"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Vrati na zadane vrijednosti"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Opcije automatskog popunjavanja za razvojne programere vraćene su na zadano"</string>
    <string name="location_category" msgid="3496759112306219062">"Lokacija"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Pokazivač lokacije trake statusa"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Prikaži za sve lokacije, uključujući mrežu i povezivost"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Primijeni potpuna mjerenja GNSS-a"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Prati sve konstelacije i frekvencije GNSS-a bez određivanja radnog omjera"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Način unosa"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Pisanje olovkom"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Kad je omogućen, odabrani način unosa prima unose olovke MotionEvent ako je fokusiran neki uređivač."</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 traci statusa"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant aplikacija"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Isključiti upravitelja pohrane?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Ažuriranje načina Ne uznemiravaj"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pauzirajte obavijesti da biste ostali usredotočeni"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Značajka nije dostupna"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Ta je značajka isključena jer usporava telefon"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Uvijek prikaži dijaloški okvir o rušenju"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Prikaži dijaloški okvir svaki put kada se aplikacija sruši"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Upotrijebite aplikaciju omogućenu za ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nema skupa aplikacija omogućenog za ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikacija omogućena za ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Postavke upravljačkog programa za grafiku"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Promjena postavki upravljačkog programa za grafiku"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kada postoji više upravljačkih programa za grafiku, za aplikacije instalirane na uređaju možete odabrati korištenje ažuriranog upravljačkog programa za grafiku."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Omogućavanje za sve aplikacije"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Odabir upravljačkog programa za grafiku"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Zadano"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Upravljački program za igru"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Upravljački program razvojnog programera"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Upravljački program za grafiku sustava"</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">"Promjene kompatibilnosti aplikacije"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Prebacivanje promjena kompatibilnosti aplikacije"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Zadane omogućene promjene"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Zadane onemogućene promjene"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Nema aplikacija"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Promjene kompatibilnosti aplikacija moguće su samo za aplikacije s mogućnošću otklanjanja pogrešaka. Instalirajte aplikaciju s mogućnošću otklanjanja pogrešaka i pokušajte ponovo."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Ovisi o drugoj postavci"</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="my_device_info_basic_info_category_title" msgid="381963187269356548">"Osnovne informacije"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Pravne i zakonske obaveze"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Pojedinosti o uređaju"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identifikatori uređaja"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Upravljanje Wi-Fijem"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Dopusti aplikaciji upravljanje Wi-Fijem"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Dopustite toj aplikaciji da uključuje ili isključuje Wi-Fi, traži Wi-Fi mreže i povezuje se s njima, dodaje ili uklanja mreže te pokreće lokalnu žarišnu točku"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Pokretanje pomoću NFC-a"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Dopusti pokretanje nakon skeniranja oznake NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="7083666814715607078">"Dopusti da se ta aplikacija pokrene nakon skeniranja oznake NFC.\nAko je to dopuštenje uključeno, aplikacija će biti dostupna kao opcija svaki put kad se otkrije oznaka."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Reproduciraj medije 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_out_summary_ongoing_call_state" msgid="475188726850090363">"Nije dostupno tijekom poziva"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Preuzmi poziv na uređaju"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Ovaj se APN ne može promijeniti."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Sprječavanje zvonjenja"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Istovremeno pritisnite tipku za uključivanje i pojačavanje da aktivirate"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Prečac za sprečavanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibriranje"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Bez zvuka"</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="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Da biste omogućili tu opciju, najprije promijenite opciju \"Pritisnite i zadržite tipku za uključivanje/isključivanje\" u izbornik tipke za uključivanje."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Podaci o mreži"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Naziv vašeg uređaja vidljiv je aplikacijama na vašem telefonu. Mogu ga vidjeti i drugi ljudi kada se povežete s Bluetooth uređajima ili Wi-Fi mrežom ili postavite Wi-Fi žarišnu točku."</string>
    <string name="devices_title" msgid="649715719278562515">"Uređaji"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Odabir mreže"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Nije povezano"</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">"Nije pronađena nijedna mreža. Pokušajte ponovo."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(zabranjeno)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Nema SIM kartice"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Nema"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Potrebna je SIM kartica radi povezivanja"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Potrebna je SIM kartica operatera <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> radi povezivanja"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Način željene mreže: Preferirano WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Način željene mreže: Samo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Način željene mreže: Samo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Način željene mreže: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Način željene mreže: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Način željene mreže: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Način željene mreže: Samo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Način željene mreže: Samo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Preferirani mrežni način: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Preferirani mrežni način: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Preferirani mrežni način: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Preferirani mrežni način: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Preporučeni mrežni način: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Preferirani mrežni način: globalni"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Preferirani mrežni način: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Preferirani način mreže: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Način željene mreže: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Preferirani mrežni način: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Preporučeni mrežni način: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Preporučeni mrežni način: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Preporučeni mrežni način: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Preporučeni mrežni način: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Preporučeni mrežni način: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Preporučeni mrežni način: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Preporučeni mrežni način: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Preporučeni mrežni način: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Preporučeni mrežni način: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Preporučeni mrežni način: samo NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Preporučeni mrežni način: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Preporučeni mrežni način: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Preporučeni mrežni način: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Preporučeni mrežni način: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Preporučeni mrežni način: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Preporučeni mrežni način: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Preporučeni mrežni način: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Preporučeni mrežni način: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Preporučeni mrežni način: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Preporučeni mrežni način: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (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="select_automatically" msgid="2419752566747259155">"Automatski odaberi mrežu"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Post. mobilnog operatera"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Postavljanje podatkovne usluge"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobilni podaci"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Pristupi podacima pomoću mobilne mreže"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon će automatski prijeći na tog mobilnog operatera kad bude u dometu"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"SIM nije dostupan"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Preferencija za pozive"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Preferencija 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">"Dodajte mrežu"</string>
    <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 mobilne podatke"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Aktiviran je mobilni podatkovni promet"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobilni su podaci isključeni"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Dostupno"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Dodajte SIM"</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="3984452275968408382">"Aktivno / eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Neaktivno / eSIM"</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">"Spremi"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Upotrijebi SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Isključeno"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Da biste onemogućili ovaj SIM, uklonite SIM karticu"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Dodirnite da bi se aktivirao mobilni operater <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Izbriši SIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Željena 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">"Željena vrsta mreže"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Verzija postavki mobilnog operatera"</string>
    <string name="call_category" msgid="641461844504128789">"Pozivanje"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videopozivanje putem mobilnog operatera"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Odabir sustava"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Promijeni način rada CDMA roaminga"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Odabir sustava"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Mreža"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA pretplata"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Izmjenjivanje među RUIM/SIM i NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"pretplata"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatska prijava…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Želite li dopustiti roaming podataka?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Podatke o cijeni možete saznati od svojeg mrežnog operatera."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Potrošnja podatkovnog prometa aplikacija"</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 pristupnih točaka"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"APN"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nedostupno kada je povezano s mobilnim operaterom <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Prikaži više"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Želite li uključiti uslugu mobilnog 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">"Želite li prijeći na mobilnog operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Želite li prijeći na SIM karticu?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Želite li upotrijebiti operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Istovremeno može biti aktivan samo jedan SIM.\n\nPrelaskom na mobilnog operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> neće se otkazati vaša usluga kod mobilnog operatera <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Istovremeno može biti aktivan samo jedan eSIM.\n\nPrelaskom na mobilnog operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> neće se otkazati vaša usluga kod 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">"Istovremeno može biti aktivan samo jedan SIM.\n\nPrelaskom se neće otkazati vaša usluga kod mobilnog operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Na ovom uređaju ne možete istovremeno upotrebljavati dva SIM-a. Da biste koristili operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, isključite drugi SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Prebaci na <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Isključite operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Isključivanjem SIM-a nećete otkazati uslugu"</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="4718412054243793310">"Prebacivanje na uslugu <xliff:g id="CARRIER_NAME">%1$s</xliff:g> za pozive i poruke…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Promjena mobilnog operatera nije uspjela"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Mobilni operater ne može se promijeniti zbog pogreške."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Želite li isključiti uslugu mobilnog 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">"Onemogućivanje mobilnog operatera nije uspjelo"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Nešto je pošlo po zlu i onemogućivanje mobilnog operatera nije uspjelo."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Želite li upotrebljavati dvije SIM kartice?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Ovaj uređaj može istovremeno imati dvije aktivne SIM kartice. Da biste nastavili s upotrebom samo jedne SIM kartice, dodirnite \"Ne, hvala\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Želite li ponovo pokrenuti uređaj?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Da"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Pokreni ponovo"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Ne, hvala"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Odustani"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Prebaci"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM se ne može aktivirati"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Pokušajte ponovo uključiti SIM. Ako se problem ponovi, ponovo pokrenite uređaj."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivacija mreže"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Promjena mobilnog operatera"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> je aktivan"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Dodirnite da biste ažurirali postavke SIM-a"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Prešli ste na mobilnog operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Prešli ste na drugog mobilnog operatera"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Vaša se mobilna mreža promijenila"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Postavite drugi SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Odaberite aktivnu SIM karticu ili upotrebljavajte dvije SIM kartice istovremeno"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Odaberite broj za korištenje"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Na ovom je uređaju dostupan jedan broj i istovremeno se može upotrebljavati samo jedan broj}=2{Na ovom su uređaju dostupna dva broja, ali se istovremeno može upotrebljavati samo jedan}one{Na ovom je uređaju dostupan # broj, ali se istovremeno može upotrebljavati samo jedan}few{Na ovom su uređaju dostupna # broja, ali se istovremeno može upotrebljavati samo jedan}other{Na ovom je uređaju dostupno # brojeva, ali se istovremeno može upotrebljavati samo jedan}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Aktivacija<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Trenutačno se ne može aktivirati"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Želite li upotrijebiti uslugu <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> upotrebljavat će se za mobilne podatke, pozive i SMS-ove."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Aktivne SIM kartice nisu dostupne"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Da biste se kasnije koristili mobilnim podacima, značajkama poziva i SMS-a, otvorite postavke mreže"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Želite li izbrisati taj eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Brisanjem tog SIM-a s uređaja se uklanja usluga mobilnog operatera <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>.\n\nUsluga mobilnog operatera <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> neće se otkazati."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Izbriši"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Brisanje SIM-a…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Brisanje SIM-a nije uspjelo"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"SIM se ne može izbrisati zbog pogreške.\n\nPonovo pokrenite uređaj i pokušajte još jednom."</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 Wi‑Fi mrežu za povezivanje s vašim uređajem"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nije pronađen nijedan uređaj. Provjerite je li uređaj uključen i dostupan za povezivanje."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Pokušajte ponovo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Došlo je do pogreške. Aplikacija je otkazala zahtjev za odabir uređaja."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Povezivanje je uspjelo"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Povezivanje nije uspjelo"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Pokaž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">"Lijevo"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Desni"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Futrola"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Ploča postavki"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Nametni način rada na računalu"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Nametanje eksperimentalnog načina rada na računalu na sekundarnim zaslonima"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Omogući aplikacije nepromjenjive veličine u više prozora"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Omogućuje prikaz aplikacija nepromjenjive veličine u više prozora"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Nadjačaj nametanje tamne teme"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Nadjačava značajku nametanja tamne teme tako da je uvijek uključena"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privatnost"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Dopuštenja, aktivnost na računu, osobni podaci"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Kontrole"</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 prijedlog?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Preostalo je malo slobodne pohrane. Iskorišteno je <xliff:g id="PERCENTAGE">%1$s</xliff:g>, a slobodno <xliff:g id="FREE_SPACE">%2$s</xliff:g>."</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Pošaljite povratne informacije"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Želite li nam poslati povratne informacije o tom prijedlogu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Kopirano u međuspremnik: <xliff:g id="COPY_CONTENT">%1$s</xliff:g>."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Upotreba pristupačnosti"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 aplikacija ima potpun pristup vašem uređaju}one{# aplikacija ima potpun pristup vašem uređaju}few{# aplikacije imaju potpun pristup vašem uređaju}other{# aplikacija ima potpun pristup vašem uređaju}}"</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="1417004513415772582">"Vaš mobilni operater može prikupljati podatke o vašoj lokaciji kad koristite tu uslugu za hitne pozive.\n\nPojedinosti potražite u pravilima o privatnosti svojeg mobilnog operatera."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Možda ćete izgubiti pristup preostalom vremenu ili podacima. Prije uklanjanja provjerite s davateljem usluga."</string>
    <string name="content_capture" msgid="868372905432812238">"Sadržaj aplikacije"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Dopustite aplikacijama da šalju sadržaj sustavu Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Izradi snimku memorije sustava"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Proširenje za označavanje memorije"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Proširenje za označavanje memorije olakšava pronalazak poteškoća sigurnosti memorije u aplikaciji i omogućuje povećanje sigurnosti nativnog koda."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Uključivanje MTE-a može dovesti do sporije izvedbe uređaja."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Saznajte više o MTE-u"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Omogući MTE do isključivanja"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Trebat ćete ponovo pokrenuti uređaj da biste uključili MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Trebat ćete ponovo pokrenuti uređaj da biste isključili MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Omogući MTE za jednu sesiju"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sustav će se ponovno pokrenuti i omogućiti eksperimentiranje s proširenjima za označavanje memorije (MTE). MTE može negativno utjecati na izvedbu i stabilnost sustava. Poništit će se prilikom sljedećeg ponovnog pokretanja."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Ponovno pokreni za jednu sesiju s omogućenim MTE-om"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE je već omogućen"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Izrada snimke memorije sustava"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Izrada snimke memorije sustava nije uspjela"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automatski izrađuj snimke memorije sustava"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automatski izradi snimku memorije za Android sustav kad 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š mobilni operater ne podržava hitne pozive putem Wi‑Fi poziva.\nUređaj se automatski prebacuje na mobilnu mrežu kako bi uputio hitni poziv.\nHitni pozivi mogući su samo u područjima pokrivenim mobilnim mrežama."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Upotrijebi Wi‑Fi za pozive radi poboljšanja kvalitete"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Rezervni način telefoniranja"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Ako usluga <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> nije dostupna ili je u roamingu, za pozive putem usluge <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g> koristite SIM za mob. podatke."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"rezervni način telefoniranja"</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 biste dopustili MMS poruke na usluzi <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> kad su mobilni podaci isključeni"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS poruka"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Poteškoća s kombinacijom SIM-ova"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Upotreba mobilnih operatera <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> može ograničiti funkcije. Dodirnite da biste saznali više."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Kombinacija SIM-ova"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informacije o poslovnim 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">"Rukovatelj izvješćem o programskim pogreškama"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Određuje koja je aplikacija zadužena za prečac Izvješće o programskim pogreškama na vašem uređaju."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Osobno"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Posao"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Zadane postavke sustava"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Ništa"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Taj izbor više nije važeći. Pokušajte ponovo."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Pritisnite i zadržite tipku za uključivanje/isključivanje"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Za pristup pritisnite i zadržite tipku za uklj./isklj."</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Izbornik tipke za uključivanje (/isključivanje)"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitalni asistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Pristupi digitalnom asistentu"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Otvorite izbornik tipke za uključivanje (/isključivanje)"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Za upotrebu najprije postavite zaključavanje zaslona"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Izbornik tipke za uključivanje (/isključivanje):\nistodobno pritisnite tipku za uključivanje/isključivanje i gumb za pojačavanje glasnoće"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Sprječavanje zvonjenja:\nza prečac pritisnite gumb za glasnoću"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Trajanje zadržavanja tipke"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Prilagodite osjetljivost odabirom trajanja zadržavanja tipke za uključivanje/isključivanje"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Kratko"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Dugo"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Prikaži novčanik"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Dopusti pristup novčaniku sa zaključanog zaslona"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Prikaži čitač QR koda"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Omogućite pristup čitaču QR koda sa zaključanog zaslona"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Prikaži kontrole uređaja"</string>
    <!-- no translation found for lockscreen_privacy_controls_summary (7522918441738915364) -->
    <skip />
    <!-- no translation found for lockscreen_trivial_controls_setting_toggle (2174300719855112358) -->
    <skip />
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Za upotrebu najprije uključite opciju \"Prikaži kontrole uređaja\"."</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Prikaži sat s dva retka kad je dostupan"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Sat s dva retka"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Prečaci"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="one"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
    </plurals>
    <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="volte_5G_limited_title" msgid="5908052268836750629">"Isključiti VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Time se isključuje i vaša 5G veza.\nTijekom glasovnog poziva ne možete upotrebljavati internet i neke aplikacije možda neće funkcionirati."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Obustavi izvršenje za predmemorirane aplikacije"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Nikad ne istječe."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Najam nikad ne istječe."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Dopustite preklapanja na zaslonu na Postavkama"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Dopustite aplikacije koje se mogu prikazivati iznad drugih da se preklapaju na zaslonima Postavki"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Dopusti lažni modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Dopustite ovom uređaju da pokrene uslugu lažnog modema za instrumentacijsko testiranje. Tu postavku nemojte omogućiti tijekom uobičajene upotrebe telefona"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Mediji"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Prikvači media player"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Da bi se reprodukcija brzo nastavila, media player ostaje otvoren u brzim postavkama"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Prikaži medije na zaključanom zaslonu"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Da bi se reprodukcija brzo nastavila, media player ostaje otvoren na zaključanom zaslonu"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Prikaži preporuke medija"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Na temelju vaše aktivnosti"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Sakrij player"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Prikaži player"</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="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM-ovi"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Pozivi i SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Wi-Fi pozivi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Upućujte i primajte pozive putem Wi‑Fija"</string>
    <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="9004261125829377885">"preferirano za pozive"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"preferirano za SMS-ove"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nije dostupno"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Privremeno nedostupno"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Nema SIM kartice"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Postavke mreže"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"mrežna veza, internet, bežično, podaci, wifi, wi-fi, wi fi, mobilno, mobilni uređaj, mobilni operater, 4 g, 3 g, 2 g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Vratiti internet na zadano?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Vraćanje interneta na zadano…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Rješavanje problema s povezivošću"</string>
    <string name="networks_available" msgid="3299512933684383474">"Dostupne mreže"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Da biste se prebacili na drugu mrežu, odspojite ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ veze"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Omogućite Google Fiju da upotrebljava W+ mreže radi poboljšanja brzine i pokrivenosti"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+ mreža"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIM-ovi"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktivno"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Neaktivno"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Zadano za <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"pozive"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobilne podatke"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Radi boljeg doživljaja na uređaju, aplikacije i usluge i dalje mogu tražiti Wi‑Fi mreže u bilo kojem trenutku, čak i kada je Wi‑Fi isključen. Time se primjerice mogu poboljšati značajke i usluge koje se temelje na lokaciji. To možete promijeniti u postavkama traženja Wi-Fija."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Promijeni"</string>
    <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_temp_connection_active" msgid="3430470299756236413">"Privremeno povezano"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Privremeno koristite <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Niste povezani"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobilni podaci neće se automatski povezati"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Isključiti mobilne podatke?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Nećete imati pristup podacima ni internetu putem usluge <xliff:g id="CARRIER">%s</xliff:g>. Internet će biti dostupan samo putem Wi-Fija."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"mobilnog operatera"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Vaša organizacija ne dopušta"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nije dostupno jer je uključen način rada u vrijeme spavanja"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Dovršeno je vraćanje važnosti obavijesti na zadano."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikacije"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Uređaj želi pristupiti vašim porukama. Dodirnite da biste vidjeli pojedinosti."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Dopustiti pristup porukama?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Bluetooth uređaj <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti vašim porukama.\n\nDosad se niste povezali s uređajem <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Uređaj želi pristupiti vašim kontaktima i zapisniku poziva. Dodirnite da biste vidjeli pojedinosti."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Dopustiti pristup kontaktima i zapisniku poziva?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Bluetooth uređaj <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti vašim kontaktima i zapisniku poziva. To uključuje podatke o dolaznim i odlaznim pozivima.\n\nDo sad se niste povezali s uređajem <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Svjetlina"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Zaključani zaslon"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Izgled"</string>
    <string name="category_name_color" msgid="937514550918977151">"Boja"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Ostale kontrole zaslona"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Općenito"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Koristi tamnu temu"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Koristi Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Upotreba sprječavanja zvonjenja"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Koristi Wi‑Fi žarišnu točku"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Koristi prikvačivanje aplikacije"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Koristi opcije za razvojne programere"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Koristi uslugu ispisa"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Dopusti više korisnika"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"dopustiti, više, korisnik, dopuštenje, mnogo"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Upotreba bežičnog otklanjanja pogrešaka"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Upotreba preferencija upravlj. programa za grafiku"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Koristi noćno svjetlo"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Koristi NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Koristi prilagodljivu svjetlinu"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Upotreba Wi-Fi poziva"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Pogledajte sve aplikacije"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Pametno prosljeđivanje"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Pametno prosljeđivanje omogućeno"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Pametno prosljeđivanje onemogućeno"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Postavke poziva"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Ažuriranje postavki…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Pogreška postavki poziva"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Pogreška mreže ili SIM-a."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM nije aktiviran."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Unesite telefonske brojeve"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Unesite telefonski broj"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Nedostaje telefonski broj."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"U redu"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Dopusti 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G je nesigurniji, no na nekim lokacijama može poboljšati vezu. Za hitne pozive 2G je uvijek dopušten."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> zahtijeva dostupnost 2G tehnologije"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Zahtijevaj šifriranje"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Šifriranje je sigurnije, no na nekim se lokacijama možda nećete moći povezati. Šifriranje se nikad ne zahtijeva za hitne pozive"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Sve usluge"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Prikaži pristup međuspremniku"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Primite poruku kad aplikacije pristupe tekstu, slikama ili drugom kopiranom sadržaju"</string>
    <string name="all_apps" msgid="3054120149509114789">"Sve aplikacije"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Nemoj dopustiti"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultraširokopojasno povezivanje (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomoć pri određivanju relativnog položaja uređaja u blizini koji imaju UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Isključite način rada u zrakoplovu da biste koristili UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB nije dostupan na trenutačnoj lokaciji"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Pristup fotoaparatu"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Pristup mikrofonu"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Za aplikacije i usluge"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Za aplikacije i usluge. Ako je ta postavka isključena, podaci mikrofona i dalje se mogu dijeliti kad nazovete broj hitne službe."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Prethodno"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Dalje"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Pregled boje"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Zahtjev za pristup SIM-u"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Uređaj želi pristupiti vašem SIM-u. Dodirnite da biste vidjeli pojedinosti."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Želite li dopustiti pristup SIM-u?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Bluetooth uređaj <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti podacima s vašeg SIM-a. To uključuje vaše kontakte.\n\nDok ste povezani, <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> će primati sve pozive upućene broju <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Bluetooth uređaj dostupan"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Uređaj se želi povezati. Dodirnite da biste vidjeli pojedinosti."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Želite li se povezati s Bluetooth uređajem?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> se želi povezati s ovim telefonom.\n\nDosad se niste povezivali s uređajem <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Nemoj povezati"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Poveži"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Postavke TARE-a"</string>
    <string name="tare_on" msgid="2386073225978684535">"Uključeno"</string>
    <string name="tare_off" msgid="6305694402929756726">"Isključeno"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Vraćanje na zadane postavke"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Postavke su vraćene na zadano."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maksimalan zasićeni balans"</string>
    <string name="tare_balances" msgid="731881382594747961">"Salda"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Ograničenja potrošnje"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Početno ograničenje potrošnje"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimalno ograničenje potrošnje"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maksimalno ograničenje potrošnje"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikatori"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Radnje (trošak proizvodnje)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Radnje (osnovna cijena)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Nagrade po pojedinačnom događaju"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Nagrade po sekundi trajanja događaja"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maksimalan broj nagrada po danu"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Instalacija aplikacije"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Glavna aktivnost"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Obavijest je viđena"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Obavijest je viđena u roku od 15 minuta"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interakcija s obavijestima"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interakcija s widgetima"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Ostale korisničke interakcije"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Pokretanje zadatka najvišeg prioriteta"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Izvodi se zadatak najvišeg prioriteta"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Pokretanje zadatka visokog prioriteta"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Izvodi se zadatak visokog prioriteta"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Pokretanje zadatka zadanog prioriteta"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Izvodi se zadatak zadanog prioriteta"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Pokretanje zadatka niskog prioriteta"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Izvodi se zadatak niskog prioriteta"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Pokretanje zadatka najnižeg prioriteta"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Izvodi se zadatak najnižeg prioriteta"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Sankcija za istek vremena za zadatak"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimalni saldo pri punoj bateriji (izuzeto)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimalni saldo pri punoj bateriji (apl. sustava bez korisničkog sučelja)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimalni saldo pri punoj bateriji (preostale aplikacije)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Dodatak za minimalni saldo pri punoj bateriji (alati za ažuriranje aplikacija)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Punjenje"</item>
    <item msgid="658627268149681677">"Drijemanje"</item>
    <item msgid="1599558140284643834">"Način rada za uštedu energije"</item>
    <item msgid="588427840913221601">"Stanje procesa"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Potvrdi"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Pregled"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Odabir čuvara zaslona"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Prikaz dodatnih informacija"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Na čuvaru zaslona prikazujte vrijeme, vremenske uvjete i druge informacije"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Prikaži upravljanje kućanskim uređajima"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Prikazivanje gumba za upravljanje kućanskim uređajima s čuvara zaslona"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Više postavki"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Odaberite čuvar zaslona"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Odaberite što će se prikazivati na zaslonu kad se tablet nalazi na priključnoj stanici. Uređaj može trošiti više energije kad se koristi čuvar zaslona."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Prilagodi"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Prilagodite <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Za omogućivanje podrške slobodnom obliku potrebno je ponovno pokretanje."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Za prisilno uključivanje načina radne površine na sekundarnim zaslonima potrebno je ponovno pokretanje."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Ponovno pokreni sada"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Ponovno pokreni kasnije"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Prostorni zvuk"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Zvuk s kompatibilnih medija postaje realističniji"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Praćenje glave"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Zvuk se mijenja kako pomičete glavu kako bi prirodnije zvučao"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Ograničenje brzine preuzimanja s mreže"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfigurirajte ograničenje ulazne brzine propusnosti mreže koje se primjenjuje na sve mreže koje pružaju internetsku vezu."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfiguracija ograničenja brzine preuzimanja s mreže"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Bez ograničenja"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Onemogući ograničenja za podređene postupke"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Onemogućite ograničenja upotrebe resursa sustava za podređene postupke aplikacija"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Prisilno omogući ulogu Bilješke"</string>
    <string name="enable_notes_role_summary" msgid="136916915155048249">"Omogućite integracije sustava bilježenja putem uloge Bilješke. Ako je uloga Bilješke već omogućena, ne trebate ništa."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Emitiranje"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Emitiranje aplikacije <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Slušajte emitiranja koja se reproduciraju u blizini"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Emitirajte medije na uređaje u blizini ili slušajte tuđe emitiranje"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Emitiranja"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Slušanje"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Pronađi emitiranja"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Napusti emitiranje"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skeniraj QR kôd"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Unesite zaporku"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Povezivanje nije uspjelo. Pokušajte ponovo."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Pogrešna zaporka"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Pridruživanje emitiranju nije moguće"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Da biste počeli slušati, centrirajte QR kôd u nastavku"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR kôd nije u važećem formatu"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Pretvaranje u eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Prenesite eSIM na drugi uređaj"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# aplikacija}one{# aplikacija}few{# aplikacije}other{# aplikacija}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Aplikacije instalirane u pozadini"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Proizvođač vašeg uređaja može instalirati aplikacije na vaš uređaj u pozadini ili to može dopustiti vašem mobilnom operateru i drugim partnerima.\n\nNijedna od ovdje navedenih aplikacija nije nužna za uobičajeno funkcioniranje vašeg uređaja. Možete deinstalirati aplikacije koje ne želite."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Nema aplikacija instaliranih u pozadini"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Deinstaliraj aplikaciju"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Aplikacije instalirane u posljednji # mjesec}one{Aplikacije instalirane u posljednji # mjesec}few{Aplikacije instalirane u posljednja # mjeseca}other{Aplikacije instalirane u posljednjih # mjeseci}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplikacije instalirane prije više od # mjeseca}one{Aplikacije instalirane prije više od # mjeseca}few{Aplikacije instalirane prije više od # mjeseca}other{Aplikacije instalirane prije više od # mjeseci}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Senzor otiska prsta"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Bljeskanje za obavijesti"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"O obavijestima uz bljeskanje zaslona"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Isključeno"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Uključeno/bljeskalica fotoaparata"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Uključeno/bljeskanje zaslona"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Uključeno/bljeskanje bljeskalice i zaslona"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Kad primite obavijesti ili se oglasi alarm, bljeskalica ili zaslon mogu bljeskati"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Zaslon bliješti kad primite obavijest ili kada se oglasi alarm."</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Bljeskanje za obavijesti koristite oprezno ako ste osjetljivi na svjetlo"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"bljeskanje, svjetlo, nagluhost, gubitak sluha"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Pregled"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Bljeskalica fotoaparata"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Bljeskanje zaslona"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Boja bljeskanja zaslona"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Plava"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azurna"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cijan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Proljetnozelena"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Zelena"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Žutozelena"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Žuta"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Narančasta"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Crvena"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Ruža"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Grimizna"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Ljubičasta"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Gotovo"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Odustani"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standardni"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Srednji"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Visoki"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ova se aplikacija može otvoriti samo u jednom prozoru"</string>
    <string name="note_task_button_label" msgid="1741456863714912927">"Pisanje bilježaka"</string>
</resources>
