<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Da"</string>
    <string name="no" msgid="5541738710521607130">"Ne"</string>
    <string name="create" msgid="986997212165228751">"Kreiraj"</string>
    <string name="allow" msgid="3763244945363657722">"Dozvoli"</string>
    <string name="deny" msgid="7326117222944479942">"Odbij"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Uključi"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Nepoznato"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Dodirnite da se prikažu informacije"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Još # korak vas dijeli od toga da postanete programer.}one{Još # korak vas dijeli od toga da postanete programer.}few{Još # koraka vas dijele od toga da postanete programer.}other{Još # koraka vas dijeli od toga da postanete programer.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Postali ste programer!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nema potrebe, već ste programer."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Prvo omogućite opcije za programere."</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"Samo administratori mogu pristupati postavkama programera."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Aktivan"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ne radi"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio je isključen"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Nije u romingu"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Isključena"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Povezivanje"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Povezano"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Obustavljeno"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Nepoznato"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Pregled"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Napravi manji"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Napravi veći"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Uvijek"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Prednji ekran se uključuje kada sklopite uređaj"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Samo igre, videozapisi i drugo"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Prednji ekran se uključuje za aplikacije koje sprečavaju neaktivnost ekrana"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Prevucite nagore da nastavite"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Sklopite telefon i prevucite nagore na prednjem ekranu da nastavite koristiti aplikaciju ili pričekajte nekoliko sekundi da se ekran zaključa"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Nikada"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Prednji ekran se zaključava kada sklopite uređaj"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Koristi automatsko rotiranje"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Prepoznavanje lica koristi prednju kameru da poboljša preciznost automatskog rotiranja. Slike se nikad ne pohranjuju niti šalju Googleu."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Vidljiv za sve obližnje Bluetooth uređaje (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Vidljiv za sve obližnje Bluetooth uređaje"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nije vidljiv za druge Bluetooth uređaje"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Vidljiv samo za uparene uređaje"</string>
    <string name="bluetooth_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">"Promijenite naziv uređaja"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Promijeni naziv"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Želite li prekinuti vezu s uređajem?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Uparite novi uređaj"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_screen_auto_on_title" msgid="8496443490064988240">"Automatski uključi ponovo sutra"</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="5711642363615781647">"Vaš lijevi slušni aparat je povezan.\n\nDa uparite desni, provjerite je li uključen i spreman za uparivanje."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Vaš desni slušni aparat je povezan.\n\nDa uparite lijevi, provjerite je li uključen i spreman 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 aparate"</string>
    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
    <skip />
    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
    <skip />
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Za ovaj uređaj"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Izlaz zvuka"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Informacije o izlazu zvuka"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Usmjerite zvuk na slušni aparat ili zvučnik telefona"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Srodno"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Melodija zvona i alarmi"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Zvuk tokom poziva"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Zvukovi medija i sistema"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Obavještenja"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Prema zadanim postavkama pojedinačne aplikacije određuju izlaz zvuka"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Neimenovani Bluetooth uređaj"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Pretraživanje"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Nema Bluetooth uređaja u blizini."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Zahtjev za uparivanje putem Bluetootha"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Zahtjev za uparivanje"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Dodirnite da uparite 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 ga uključite"</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 uključiti Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Aplikacija želi uključiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Aplikacija želi isključiti Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Uključivanje funkcije Bluetooth…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Isključivanje funkcije Bluetooth…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Zahtjev za uspostavljanje Bluetooth veze"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Zahtjev za pristup imeniku"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Zahtjev za pristup porukama"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Uređaj je vidljiv drugim uređajima kao \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\""</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Uključite Bluetooth za povezivanje s drugim uređajima."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vaši uređaji"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Uparite novi uređaj"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Onemogući rasterećenje Bluetootha A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Onemogući rasterećenje Bluetootha LE audio"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Ponovo pokrenuti?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Da promijenite ovu postavku, potrebno je ponovo pokrenuti uređaj."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Ponovo pokreni"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Otkaži"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Onemogući Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Onemogućava funkciju Bluetooth LE Audio ako uređaj podržava mogućnosti hardvera za LE Audio."</string>
    <string name="bluetooth_leaudio_mode" msgid="5206961943393400814">"Bluetooth LE Audio način rada"</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Prikaži prekidač za LE Audio u Detalj. uređ."</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Zaobiđi Listu dozvoljenih za Bluetooth LE Audio"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Koristite LE Audio prema zadanim postavkama čak i ako nije potvrđeno da LE Audio periferni uređaj ispunjava kriterije Liste dozvoljenih."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Uređaji za medije"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Uređaji za pozive"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Drugi uređaji"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Sačuvani uređaji"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Povezano s računom"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Prethodno korišteno s računom"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth će se uključiti za uparivanje"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Postavke veze"</string>
    <string name="connected_device_previously_connected_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="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Prikaži sve"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Pisaljka"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Pritiskanje gornjeg dugmeta"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (radni profil)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Pisanje u poljima za tekst"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignoriranje svih pritisaka dugmeta za pisaljku"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Pisaljka"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"U blizini nije pronađen nijed. prijenos zvuka"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum i vrijeme"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proksi server"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Obriši"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Priključak za proksi"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Zaobilazni proksi za"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Vrati na zadano"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Gotovo"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Naziv host računara za proksi"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Pažnja"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Uredu"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Uneseni naziv host računara nije važeći."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Unesena lista isključenja nije odgovarajuće formatirana. Unesite listu isključenih domena u obliku liste stavki odvojenih zarezom."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Morate popuniti adresno polje"</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Adresno polje mora biti prazno ako je server polje prazno."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Uneseni port nije važeći."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Preglednik koristi HTTP proksi, ali ga druge aplikacije ne mogu koristiti."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL za PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Pinguj ime računara (www.google.com) IPv4:"</string>
    <string name="radio_info_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">"Naprijed"</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 sistema"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Ukloni"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Dodajte 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 sistema"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Sistemski zadano"</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će podržavati ovu postavku."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Postavite jezik za svaku aplikaciju."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Vaš sistem, apikacije i web lokacije koriste prvi preferirani jezik koji je podržan."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Da odaberete jezik za svaku aplikaciju, idite u 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 sistema u %s?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Dodati %s u preferirane jezike?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Ovo aplikacijama i web lokacijama daje do znanja da je i ovo vaš preferirani jezik."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Postavke uređaja i regionalne postavke će se promijeniti."</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 jezik se ne može koristiti kao jezik sistema, ali ste ga postavili 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">"Postavite preference za jedinice i brojeve"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Omogućite aplikacijama da znaju vaše regionalne postavke da mogu personalizirati vaše iskustvo."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplikacije će koristiti vaše regionalne postavke kada je to moguće."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatura"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Prvi dan u sedmici"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Postavke brojeva"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Koristi zadano"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celzijus (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Farenhajt (°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, koristit će svoje zadane postavke jezika/zemlje."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Saznajte više o postavkama jezika."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Dodatne postavke"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Rodni oblici obraćanja"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Postavite kako želite da vam se obraćaju"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Aplikacije mogu koristiti rodne oblike obraćanja da personaliziraju način na koji vam se obraćaju."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Nije navedeno"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Ženski rod"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Muški rod"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutralno"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Ukloniti odabrani jezik?}one{Ukloniti odabrane jezike?}few{Ukloniti odabrane jezike?}other{Ukloniti odabrane jezike?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekst će biti prikazan na drugom jeziku"</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Ne mogu se ukloniti svi jezici"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Zadržite najmanje jedan preferirani jezik"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Nije dostupan kao jezik sistema"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Pomjeri nagore"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Pomjeri nadolje"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Pomjeri na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Pomjeri na dno"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Ukloni jezik"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Odaberite aktivnost"</string>
    <string name="cancel" msgid="5780102414089664898">"Otkaži"</string>
    <string name="okay" msgid="4827099303045669054">"Uredu"</string>
    <string name="forget" msgid="3754013654135912783">"Zaboravi"</string>
    <string name="save" msgid="3125033126936493822">"Sačuvaj"</string>
    <string name="done" msgid="7497982645646431310">"Gotovo"</string>
    <string name="apply" msgid="7834684883190163536">"Primijeni"</string>
    <string name="share" msgid="8502235338607613795">"Dijeli"</string>
    <string name="add" msgid="8335206931421683426">"Dodaj"</string>
    <string name="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čica za postavke"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Način rada u avionu"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bežična veza i mreže"</string>
    <string name="roaming" msgid="3055365654530847985">"Roming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Povezivanje na usluge prijenosa podataka u romingu"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Povezivanje na usluge prijenosa podataka u romingu"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Mogu nastati troškovi rominga."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Automatski postavi vrijeme"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Postavi automatski"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Lokacija će se koristiti za postavljanje vremenske zone kada je ovaj prekidač uključen"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Koristi zadani format jezika/zemlje"</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">"Odaberite vremensku zonu"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Pretražite regiju"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Regija"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Odaberite odstupanje od UTC-a"</string>
    <string name="zone_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">"Koristi <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">"Koristi <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Ne koristi ljetno računanje vremena."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Ljetno računanje vremena"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardno vrijeme"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Odabir prema regiji"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Odabir prema odstup. od UTC-a"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Zaključavanje nakon isteka vremena ekrana"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon isteka vremena"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Odmah nakon isteka vremena, osim kada ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> drži otključanim"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon isteka vremena, osim kada ga <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> drži otključanim"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Dodavanje teksta na zaklj. ekranu"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ništa"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Npr. Edinov 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="4273299717586679786">"{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 odobrenjem za Uređaje u blizini mogu otkriti relativan položaj povezanih uređaja."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Pristup lokaciji je isključen za aplikacije i usluge. Lokacija uređaja se i dalje može slati hitnim službama kada pozovete broj za hitne slučajeve ili pošaljete SMS na njega."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Saznajte više o postavkama lokacije"</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"Promijenite pristup lokaciji u Postavke &gt; Sigurnost i privatnost &gt; Kontrole privatnosti"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Računi"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sigurnost"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifriranje i akreditivi"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Zaključani ekran"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Šta prikazati"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nije dostupno"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Sigurnosni status"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Zaključavanje ekrana, 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, odobrenja"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Lice je 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 radni profil"</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">"Postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Koristite lice za autentifikaciju"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Započni"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Ako je otključavanje licem za pristupačnost isključeno, neki koraci za postavljanje možda neće funkcionirati ispravno s TalkBackom."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Nazad"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Nastavi postavljanje"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Koristi postavku za pristupačnost"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Otkaži"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Ne, hvala"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Prihvatam"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Više"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Otključajte pomoću lica"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Dozvolite otključavanje licem"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Koristite lice za autentifikaciju"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Koristite lice za otključavanje telefona ili odobravanje kupovina.\n\nNapomena: ne možete koristiti lice za otključavanje ovog uređaja. Za više informacija obratite se administratoru svoje organizacije."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Koristite lice za otključavanje telefona, odobravanje kupovine ili prijavu u aplikacije."</string>
    <string name="security_settings_face_enroll_introduction_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">"Namjestite lice u centar 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">"Uredu"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Vrijeme za registraciju lica je isteklo. 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 performanse 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 performanse"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Postavite otključavanje licem"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Izbrišite trenutni model lica da ponovo postavite otključavanje licem.\n\nModel lica će se trajno i sigurno izbrisati.\n\nNakon brisanja, za otključavanje telefona ili autentifikaciju u aplikacijama će vam trebati PIN, uzorak ili lozinka."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Izbrišite trenutni model lica da ponovo postavite otključavanje licem.\n\nModel lica će se trajno i sigurno izbrisati.\n\nNakon brisanja, za otključavanje telefona ili autentifikaciju u aplikacijama će vam trebati otisak prsta, PIN, uzorak ili lozinka."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Otključavanje licem za"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Kada koristite otključavanje licem"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Oči moraju biti otvorene"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Da otključate telefon, oči vam moraju biti otvorene"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Uvijek traži potvrdu"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Za korištenje otključavanja licem u aplikacijama uvijek se traži potvrda."</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">"Izbrisati model lica?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Model lica će se trajno i sigurno izbrisati.\n\nNakon brisanja će vam za otključavanje telefona ili autentifikaciju u aplikacijama trebati PIN, uzorak ili lozinka."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Model lica će se trajno i sigurno izbrisati.\n\nNakon brisanja će vam za otključavanje telefona trebati PIN, uzorak ili lozinka."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Model lica će se trajno i sigurno izbrisati.\n\nNakon brisanja će vam trebati otisak prsta, PIN, uzorak ili lozinka da otključate telefon ili izvršite autentifikaciju u aplikacijama."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Model lica će se trajno i sigurno izbrisati.\n\nNakon brisanja će vam trebati otisak prsta, PIN, uzorak ili lozinka da otključate telefon."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Otključajte telefon pomoću otključavanja licem"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Otisak prsta"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Otisak prsta"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Kada koristite otključavanje otiskom prsta"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Otisak prsta za posao"</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 prstiju}other{Dodano je # otisaka prstiju}}"</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">"Postavite otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Dozvolite otklj. otiskom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Koristite otisak 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">"Vi upravljate svime"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Vi i vaše dijete imate kontrolu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Napomena"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Pomoću otiska prsta otključavajte telefon ili odobravajte kupovinu.\n\nNapomena: otisak prsta ne možete koristiti za otključavanje ovog uređaja. Za više informacija, obratite se administratoru svoje organizacije"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Ne, hvala"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Prihvatam"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Preskočiti otisak prsta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Postavljanje otiska prsta traje svega minutu ili dvije. Ako ovo preskočite, otisak prsta možete dodati kasnije u postavkama."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Kada vidite ovu ikonu, izvršite autentifikaciju otiskom prsta da se prijavite u aplikacije, odobrite kupovinu i drugo"</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 funkcionira"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Otključavanje otiskom prsta kreira jedinstveni model vašeg otiska prsta radi potvrde vašeg identiteta. Da kreirate ovaj model otiska prsta tokom postavljanja, trebate snimiti slike otiska prsta u različitim položajima."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Otključavanje otiskom prsta kreira jedinstveni model otiska prsta vašeg djeteta radi potvrde vašeg identiteta. Da kreira ovaj model otiska prsta tokom postavljanja, dijete treba snimiti slike otiska prsta u različitim položajima."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Za najbolje rezultate koristite zaštitu ekrana koja ima oznaku Proizvedeno za Google. Moguće je da vaš otisak prsta neće funkcionirati s drugim zaštitama ekrana."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Za najbolje rezultate koristite zaštitu ekrana koja ima oznaku Proizvedeno za Google. Moguće je da otisak prsta vašeg djeteta neće funkcionirati s drugim zaštitama ekrana."</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 pomoću sata"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Kada postavite otključavanje licem i otključavanje otiskom prsta, telefon će zatražiti otisak prsta kada nosite masku ili se nalazite u mračnom području.\n\nOtključavanje pomoću sata je drugi praktični način za otključavanje telefona, naprimjer kada su vam prsti vlažni ili lice nije prepoznato."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"Otključavanje pomoću sata je drugi praktični način za otključavanje telefona, naprimjer kada vam otisak prsta nije prepoznat."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"Otključavanje pomoću sata je drugi praktični način za otključavanje telefona, naprimjer kada vam lice nije prepoznato."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Koristite otisak prsta ili sat da"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Koristite lice ili sat da"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Koristite lice, otisak prsta ili sat da"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Koristite sat da"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Pomoću lica ili sata"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Pomoću otiska prsta ili sata"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Pomoću lica, otiska prsta ili sata"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Pomoću sata"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Najprije postavite otključavanje licem ili otiskom prsta"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Kada se vaše lice ili otisak prsta ne prepozna, možete otključati pomoću sata"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Najprije postavite otključavanje otiskom prsta"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Kada se vaš otisak prsta ne prepozna možete otključati pomoću sata"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Najprije postavite otključavanje licem"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Kada se vaše lice ne prepozna možete otključati pomoću sata"</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 <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Dodani su otisci prstiju i <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Dodani su lice i <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 <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 <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Otključavanje udaljenog autentifikatora"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Sat je dodan"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Postavite sat"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Otključavanje pomoću sata je još jedan praktičan način otključavanja telefona, npr. kada su vam vlažni prsti ili kada se ne prepoznaje vaše lice.\n\nTelefon možete otključati pomoću sata kada:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Ne sada"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Nastavi"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Više"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Kako funkcionira"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Sat mora biti otključan, nalaziti se na zglobu šake i nadohvat ovog telefona. Dok je sat na zglobu šake, više ga nećete morati otključavati."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Kada se telefon otključa, dobit ćete obavještenje na satu. Ako se telefon otključao kada niste namjeravali, dodirnite obavještenje da ponovo zaključate telefon."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Vi upravljate svime"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Možete ukloniti sat iz Otključavanja pomoću sada bilo kada u Postavkama"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Dodirnite obavještenje"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Prevucite nagore na zaključanom ekranu"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Odaberite sat"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Dostupni satovi"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Otkaži"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Potvrdi"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Spremni ste!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Sada možete otključati telefon pomoću sata kada prevučete nagore na zaključanom ekranu ili dodirnete obavještenje"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Gotovo"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Otključavanje pomoću sata"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Možete otključati telefon pomoću sata kada prevučete nagore na zaključanom ekranu ili dodirnete obavještenje"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Da koristite Otključavanje pomoću sata, sat mora biti otključan, nalaziti se na zglobu šake, nadohvat ovog telefona i povezan s njim. Ako se prekine veza, trebate otključati telefon da možete koristiti Otključavanje pomoću sata.\n\nImajte na umu:\nu datom trenutku možete imati samo jedan postavljen sat. Da dodate drugi sat, prvo uklonite trenutni."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Saznajte više o Otključavanju pomoću sata"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Dodaj sat"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Uklanjanje sata"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Otključavanje otiskom prsta i licem"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Otključavanje licem i otiskom prsta za radni profil"</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">"Lice i otisci prstiju su dodani"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Lice i otisak prsta su dodani"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Kada postavite otključavanje licem i otključavanje otiskom prsta, telefon će tražiti otisak prsta ako nosite masku ili se nalazite u mračnom 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">"Koristite 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">"Uredu"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Nije moguće postaviti otključavanje licem"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Izađite iz podijeljenog ekrana da postavite otključavanje licem"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Nije moguće postaviti otisak prsta"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Izađite iz pod. ekrana da post. otklj. otiskom"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"Uredu"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Preskočiti zaključani ekran?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Ipak preskoči"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Nazad"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Preskoči"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dodirnite senzor"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Dodirnite dugme za uključivanje bez pritiskanja"</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 poleđini telefona. Koristite kažiprst."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Senzor za otisak prsta se nalazi na ekranu. Na sljedećem ekranu ćete snimiti 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">"Pomjerajte prst po ekranu da pronađete senzor. Dodirnite i zadržite senzor za otisak prsta."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustracija sa uređajem i lokacijom senzora za otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Naziv"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Uredu"</string>
    <string name="security_settings_fingerprint_enroll_dialog_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 kad osjetite vibraciju"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Držite prst ravno na senzoru dok ne osjetite vibraciju"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Bez pritiskanja dugmeta držite otisak prsta na senzoru dok ne osjetite vibraciju.\n\nMalo pomaknite prst svaki put. Na ovaj način se snima veći dio otiska prsta."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Dodirnite i zadržite senzor za otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Podignite prst i ponovo dodirnite senzor"</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">"Pratite ikonu otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Nastavite podizati prst da dodate različite dijelove otiska prsta"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Dodirnite i zadržite svaki put kada se ikona otiska prsta pomjeri. Na ovaj način se snima 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 srednji 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">"Konačno, postavite desni rub prsta na senzor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Stranu prsta postavite na senzor i zadržite, a zatim ga prebacite na drugu stranu"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Na ovaj način se snima veći dio otiska prsta"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Prijava otiska prsta: <xliff:g id="PERCENTAGE">%d</xliff:g> posto"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Prijavljeno je <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> posto"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Dodan je otisak prsta"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Dodirnite da otključate bilo kada"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Dodirnite senzor da otključate uređaj, čak i kada je ekran isključen. Ovo povećava mogućnost slučajnog otključavanja."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Ekran, otključavanje"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Ostavi za kasnije"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Podignite prst i ponovo dodirnite senzor"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Stranu prsta postavite na senzor i zadržite, a zatim ga prebacite 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">"Odabrali ste da koristite otisak prsta kao jedan od načina za otključavanja telefona. Ukoliko sada preskočite ovaj korak, morat ćete ga postaviti kasnije. Postavka traje otprilike samo jednu minutu."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Preskočiti postavljanje opcija <xliff:g id="OPTIONS">%s</xliff:g>?"</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 lozinke?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Preskočiti postavljanje lozinke i lica?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Preskočiti postavljanje lozinke i otiska prsta?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Preskočiti postav. lozinke, 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 ekrana"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Gotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ups, to nije senzor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Dodirnite senzor na poleđini telefona. Koristite kažiprst."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Nije moguće izvršiti postavljanje otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Možete pokušati ponovo sada ili postaviti otisak prsta kasnije u Postavkama."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Možete pokušati ponovo sada ili postaviti otisak prsta kasnije."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Postavljanje otiska prsta je isteklo"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Možete postaviti otisak prsta kasnije u Postavkama."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Nešto nije uredu. Možete postaviti otisak prsta kasnije u Postavkama."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Možete postaviti otisak prsta kasnije."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Nešto nije uredu. Možete postaviti otisak prsta kasnije."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Dodajte još jedan"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Naprijed"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Opcija zaključavanja ekrana je onemogućena. Da saznate više, kontaktirajte administratora organizacije."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"I dalje možete koristiti otisak prsta da odobrite kupovine i pristup aplikaciji."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Podignite prst, zatim ponovo dodirnite senzor"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Nije moguće koristiti senzor za otisak prsta"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Posjetite pružaoca usluga za popravke."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Više postavki sigurnosti"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Zaključavanje radnog profila, šifriranje i drugo"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Šifriranje, akreditivi i drugo"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"sigurnost, više postavki sigurnosti, više postavki, napredne postavke sigurnosti"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Više postavki privatnosti"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Dodatna sigurnost i privatnost"</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">"Radni profil"</string>
    <string name="private_space_title" msgid="1752064212078238723">"Privatni prostor"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Ostavite privatne aplikacije zaključane i sakrivene"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Držite privatne aplikacije u zasebnom prostoru koji možete sakriti ili zaključati"</string>
    <string name="private_space_lock_title" msgid="7230836881433350526">"Zaključavanje privatnog prostora"</string>
    <string name="private_space_one_lock_summary" msgid="2106513606571219068">"Privatni prostor možete otključati na isti način kao što otključavate uređaj ili odaberite drugi način zaključavanja"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Koristi zaključavanje ekrana uređaja"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Otključavanje licem i otiskom prsta"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Otključavanje otiskom prsta"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Otključavanje licem"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Dodirnite da postavite"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="3614016453395789051">"Otključavanje otiskom prsta za privatni prostor"</string>
    <string name="private_space_face_unlock_title" msgid="462248384776453613">"Otključavanje licem za privatni prostor"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Načini otključavanja"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Isto kao i zaključavanje ekrana uređaja"</string>
    <string name="private_space_new_lock_title" msgid="9056139964133004094">"Odabrati novo zaključavanje privatnog prostora?"</string>
    <string name="private_space_auto_lock_title" msgid="8663409382910601261">"Automatsko zaključavanje privatnog prostora"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"Možete automatski zaključati privatni prostor ako niste koristili uređaj neko vrijeme"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Svaki put kada se ekran zaključa"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"Nakon 5 minuta neaktivnosti"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Nikada"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Sakrij kada je zaključano"</string>
    <string name="privatespace_hide_page_title" msgid="8417507414027827566">"Sakrij privatni prostor kada je zaključan"</string>
    <string name="privatespace_hide_page_summary" msgid="5525422595477989312">"Kako drugi ne bi saznali da imate privatni prostor na uređaju, možete ga sakriti s liste aplikacija"</string>
    <string name="privatespace_access_header" msgid="6066826215718835041">"Pristupite privatnom prostoru kada je sakriven"</string>
    <string name="privatespace_search_description" msgid="3121043205513022357">"S liste aplikacija unesite \"privatni prostor\" u traku za pretr."</string>
    <string name="privatespace_tap_tile_description" msgid="8346440188590931635">"Dodirnite karticu privatnog prostora"</string>
    <string name="privatespace_unlock_description" msgid="3177710543121916413">"Otključajte privatni prostor"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Isključeno"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Uključeno"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Sistem"</string>
    <string name="private_space_delete_title" msgid="636873505724100006">"Izbriši privatni prostor"</string>
    <string name="private_space_delete_header" msgid="4594429153176776184">"Izbrisati privatni prostor?"</string>
    <string name="private_space_delete_summary" msgid="3344372988408565545">"Privatni prostor će se ukloniti s uređaja. Sve privatne aplikacije i podaci će se izbrisati. Ovu radnju ne možete opozvati."</string>
    <string name="private_space_accounts" msgid="1078277762792056395">"Sljedeći računi će se ukloniti iz vašeg privatnog prostora:"</string>
    <string name="private_space_delete_button_label" msgid="1256981385318225002">"Izbriši"</string>
    <string name="private_space_confirm_deletion_header" msgid="3468651585498942977">"Brisanje privatnog prostora…"</string>
    <string name="private_space_confirm_deletion_summary" msgid="342544588554284686">"Ovo će potrajati nekoliko trenutaka"</string>
    <string name="private_space_deleted" msgid="7692240901492540053">"Privatni prostor je izbrisan"</string>
    <string name="private_space_delete_failed" msgid="7705795653796174741">"Brisanje privatnog prostora nije uspjelo"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Privatni prostor je otključan"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Postavite zaključavanje ekrana"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Da koristite privatni prostor, postavite zaključavanje ekrana na uređaju"</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Postavite zaključavanje ekrana"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Otkaži"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Otkaži"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Postavi"</string>
    <!-- no translation found for private_space_setup_title (2272968244329821450) -->
    <skip />
    <!-- no translation found for private_space_hide_apps_summary (4418722947376042418) -->
    <skip />
    <!-- no translation found for private_space_setup_sub_header (5454598292017819146) -->
    <skip />
    <!-- no translation found for private_space_separate_account_text (4492251315012955548) -->
    <skip />
    <!-- no translation found for private_space_protected_lock_text (9123250938334372735) -->
    <skip />
    <!-- no translation found for private_space_install_apps_text (5693139160766464498) -->
    <skip />
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Aplikacije u vašem privatnom prostoru se neće prikazivati u upravitelju odobrenja, na kontrolnoj tabli za privatnost ni u drugim postavkama kada je privatni prostor zaključan.\n\nPrivatni prostor se ne može premjestiti na novi uređaj. Morate postaviti drugi privatni prostor ako ga želite koristiti na drugom uređaju.\n\nAko neko poveže vaš uređaj s računarom ili na njega instalira štetne aplikacije, možda će moći pristupiti vašem privatnom prostoru."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Postavljanje privatnog prostora…"</string>
    <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Obavještenja iz aplikacija u privatnom prostoru su sakrivena kada je prostor zaključan"</string>
    <!-- no translation found for private_space_explore_settings_title (1448128245941571654) -->
    <skip />
    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
    <skip />
    <string name="private_space_error_screen_title" msgid="739381738044418346">"Postavljanje privatnog prostora nije uspjelo"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Pokušaj ponovo"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Koristiti zaklj. ekrana za otklj. priv. prostora?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Privatni prostor možete otključati na isti način kao što otključavate uređaj ili odaberite drugi način zaključavanja"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Koristi zaključavanje ekrana"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Odaberite novi način zaključavanja"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Sve je spremno!"</string>
    <string name="private_space_access_text" msgid="4433988836344567888">"Da pronađete privatni prostor, idite na listu aplikacija i kliznite nadolje"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Gotovo"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Kliznite nadolje da pronađete privatni prostor"</string>
    <string name="private_space_retry_signin_title" msgid="8090276618867918844">"Prijava"</string>
    <string name="private_space_retry_summary" msgid="1920444015972648774">"Prijavite se na račun da ga koristite s privatnim prostorom"</string>
    <string name="private_space_skip_login_label" msgid="7078019409056628192">"Ne sada"</string>
    <string name="private_space_continue_login_label" msgid="7779965766333065391">"Nastavi"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Odaberite zaključavanje za privatni prostor"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"Privatni prostor možete otključati pomoću otiska prsta. Iz sigurnosnih razloga ova opcija zahtijeva alternativni način zaključavanja."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Postavite PIN za privatni prostor"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Postavite lozinku za privatni prostor"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Postavite uzorak za privatni prostor"</string>
    <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikacije i obavještenja"</string>
    <string name="private_space_notifications_title" msgid="3456249671149740404">"Osjetljiva obavještenja na zaključanom ekranu"</string>
    <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Prikaz osjetljivog sadržaja kada je privatni prostor otključan"</string>
    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
    <skip />
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Broj otisaka prstiju koje možete dodati: <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 još 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">"Nećete moći koristiti otisak prsta da otključate radni profil, odobrite kupovine niti da se prijavite 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">"Postavite zaključavanje ekrana"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Za dodatnu sigurnost postavite PIN, uzorak ili lozinku za ovaj uređaj."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Postavi zaključavanje ekrana"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Postavite zaključavanje ekrana"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Za dodatnu sigurnost postavite PIN, uzorak ili lozinku 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 da otključate"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Zaključavanje ekrana"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Odaberite zaključavanje ekrana"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Odaberite novo zaključ. ekrana"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Odaberite zaključavanje za poslovne aplikacije"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Odaberite novo poslovno zaklj."</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Za dodatnu sigurnost postavite alternativni način zaključavanja ekrana"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Odaberite rezervni način zaključavanja ekrana"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Ako zaboravite radnju za zaključavanje ekrana, vaš IT administrator je neće moći 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 zaboravite ovo zaključavanje, tražite od IT administratora da ga poništi"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opcije zaključavanja ekrana"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opcije zaključavanja ekrana"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Automatska potvrda otključavanja"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Automatsko otključavanje prilikom unosa ispravnog PIN-a od 6 ili više cifara. Ovo je manje sigurno od potvrđivanja dodirom tipke Enter."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Automatsko potvrđivanje ispravnog PIN-a"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Potvrđivanje PIN-a dodirom tipke Enter je sigurnije od korištenja opcije automatskog potvrđivanja"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Unesite PIN uređaja da omogućite automatsko potvrđivanje"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Unesite PIN uređaja da onemogućite automatsko potvrđivanje"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zaključavanje radnog profila"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ništa"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Prevlačenje 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">"Lozinka"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ne sada"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Trenutni način zaključavanja ekrana"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Uzorak • Otisak prsta"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Otisak prsta"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Lozinka • Otisak prsta"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Nastavi bez postavljanja otiska prsta"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Uzorak • Lice"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Lice"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Lozinka • Lice"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Nastavite s otključavanjem licem"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Nastavite bez otiska prsta ili prepoznavanja lica"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ništa"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Prevlačenje prstom"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Uzorak"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Lozinka"</string>
    <string name="unlock_disable_frp_warning_title" msgid="2545569051372893686">"Ukloniti sve vrste otključavanja uređaja?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Želite li ukloniti zaštitu profila?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Uzorak štiti telefon ako ga izgubite ili ga neko ukrade"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Uzorak štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim također brišete model otiska prsta pohranjen na uređaju. Nećete moći koristiti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Uzorak štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Uzorak štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim brišete model otiska prsta pohranjen na uređaju. Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice niti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN štiti telefon ako ga izgubite ili ga neko ukrade"</string>
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys" msgid="6497861740382402784">"Izgubit ćete sačuvane podatke, kao što je PIN.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Uklonit će se kartice postavljene za beskontaktno plaćanje.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Novčanik i druge aplikacije za koje je potrebno otključati uređaj možda neće funkcionirati ispravno."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim također brišete model otiska prsta pohranjen na uređaju. Nećete moći koristiti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys" msgid="8930057076658360799">"Izgubit ćete sačuvane podatke, kao što su PIN i model otiska prsta.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Uklonit će se kartice postavljene za beskontaktno plaćanje.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Novčanik i druge aplikacije za koje je potrebno otključati uređaj možda neće funkcionirati ispravno."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys" msgid="979399855891561038">"Izgubit ćete sačuvane podatke, kao što su PIN i model lica.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Uklonit će se kartice postavljene za beskontaktno plaćanje.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Novčanik i druge aplikacije za koje je potrebno otključati uređaj možda neće funkcionirati ispravno."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim brišete model otiska prsta pohranjen na uređaju. Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice niti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys" msgid="7019955731206729909">"Izgubit ćete sačuvane podatke, kao što su PIN, model lica i model otiska prsta.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Uklonit će se kartice postavljene za beskontaktno plaćanje.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Novčanik i druge aplikacije za koje je potrebno otključati uređaj možda neće funkcionirati ispravno."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Lozinka štiti telefon ako ga izgubite ili ga neko ukrade"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Lozinka štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim također brišete model otiska prsta pohranjen na uređaju. Nećete moći koristiti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Lozinka štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Lozinka štiti telefon ako ga izgubite ili ga neko ukrade.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim brišete model otiska prsta pohranjen na uređaju. Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice niti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funkcije zaštite uređaja neće raditi bez zaključavanja ekrana."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Funkcije za zaštitu uređaja neće raditi bez zaključavanja ekrana.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim također brišete model otiska prsta pohranjen na uređaju. Nećete moći koristiti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Funkcije za zaštitu uređaja neće raditi bez zaključavanja ekrana.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Funkcije za zaštitu uređaja neće raditi bez zaključavanja ekrana.<xliff:g id="EMPTY_LINE">

</xliff:g>Ovim brišete model otiska prsta pohranjen na uređaju. Vaš model lica će se također trajno i sigurno izbrisati. Nećete moći koristiti lice niti otisak prsta za autentifikaciju u aplikacijama."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Izbriši"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže jak PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novi PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novi uzorak, PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novo zaključavanje ekrana"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Pokušajte ponovo. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. pokušaj od <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Vaši podaci će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ako u sljedećem pokušaju unesete neispravan obrazac, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ako u sljedećem pokušaju unesete neispravan PIN, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ako u sljedećem pokušaju unesete neispravnu lozinku, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ako u sljedećem pokušaju unesete neispravan obrazac, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ako u sljedećem pokušaju unesete neispravan PIN, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ako u sljedećem pokušaju unesete neispravnu lozinku, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ako u sljedećem pokušaju unesete neispravan uzorak, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ako u sljedećem pokušaju unesete neispravan PIN, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ako u sljedećem pokušaju unesete neispravnu lozinku, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="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 koristite samo brojeve, mora imati najmanje 1 cifru}one{Ako koristite samo brojeve, mora imati najmanje # cifru}few{Ako koristite samo brojeve, mora imati najmanje # cifre}other{Ako koristite samo brojeve, mora imati najmanje # cifara}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN mora sadržavati najmanje # cifru}one{PIN mora sadržavati najmanje # cifru}few{PIN mora sadržavati najmanje # cifre}other{PIN mora sadržavati najmanje # cifara}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN mora sadržavati najmanje # cifru, ali se radi dodatne sigurnosti preporučuje {minAutoConfirmLen}-cifreni PIN}one{PIN mora sadržavati najmanje # cifru, ali se radi dodatne sigurnosti preporučuje {minAutoConfirmLen}-cifreni PIN}few{PIN mora sadržavati najmanje # cifre, ali se radi dodatne sigurnosti preporučuje {minAutoConfirmLen}-cifreni PIN}other{PIN mora sadržavati najmanje # cifara, ali se radi dodatne sigurnosti preporučuje {minAutoConfirmLen}-cifreni PIN}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Ukupan broj znakova mora biti manji od #}one{Ukupan broj znakova mora biti manji od #}few{Ukupan broj znakova mora biti manji od #}other{Ukupan broj znakova mora biti manji od #}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Ukupan broj cifara mora biti manji od #}one{Ukupan broj cifara mora biti manji od #}few{Ukupan broj cifara mora biti manji od #}other{Ukupan broj cifara mora biti manji od #}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Administrator uređaja ne dozvoljava korištenje nedavnog PIN-a"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Ne može sadržavati nevažeći znak"</string>
    <string name="lockpassword_password_requires_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 cifru}one{Mora sadržavati najmanje # cifru}few{Mora sadržavati najmanje # cifre}other{Mora sadržavati najmanje # cifara}}"</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 broj}one{Mora sadržavati najmanje # znak koji nije broj}few{Mora sadržavati najmanje # znaka koja nisu brojevi}other{Mora sadržavati najmanje # znakova koji nisu brojevi}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Administrator uređaja ne dozvoljava korištenje nedavne lozinke"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Nije dozvoljen rastući, opadajući ili ponavljajući niz cifara"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potvrdi"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Obriši"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zaključavanje ekrana je već promijenjeno. Pokušajte ponovo s novim zaključavanjem ekrana."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Otkaži"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Naprijed"</string>
    <string name="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">"Pouzdani agenti"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Da biste ovo koristili, prvo postavite zaključavanje ekrana"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Nema"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktivni pouzdani agent}one{# aktivni pouzdani agent}few{# aktivna pouzdana agenta}other{# aktivnih pouzdanih agenata}}"</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_group_late_bonding" msgid="3047893658902159692">"Potvrdite da dodate drugi dio audio uređaja"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Kôd za uparivanje putem Bluetootha"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Upišite kod za uparivanje, zatim pritisnite Return ili Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN sadrži slova ili simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Obično 0000 ili 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Mora imati 16 znamenki"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Možda ćete morati otkucati ovaj PIN i na drugom uređaju."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Možda ćete morati otkucati ovaj pristupni kôd na drugom uređaju."</string>
    <string name="bluetooth_paring_group_msg" msgid="2455293929036668131">"Potvrdite da uparite s audio uređajem"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Dozvoli pristup kontaktima i historiji poziva"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Također dozvolite pristup kontaktima i historiji poziva"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Podaci će se koristiti za obavještenja o pozivu i još mnogo toga"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nije uspjelo povezivanje sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dostupni uređaji"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Poveži se"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Prekini vezu"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Upari i poveži"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Kada je Bluetooth uključen, uređaj može komunicirati s drugim Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"Kada je Bluetooth uključen, uređaj može komunicirati s drugim Bluetooth uređajima u blizini. Funkcije kao što su Quick Share, Pronađi moj uređaj i lokacija uređaja koriste Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Kada je Bluetooth uključen, uređaj može komunicirati s Bluetooth uređajima u blizini.\n\nDa se poboljša iskustvo na uređaju, aplikacije i usluge i dalje mogu skenirati uređaje u blizini u bilo kojem trenutku, čak i kada je Bluetooth isključen. Ovo se, naprimjer, može koristiti da se poboljšaju funkcije i usluge zasnovane na lokaciji. Ovo možete promijeniti u postavkama Bluetooth skeniranja."</string>
    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Kada je Bluetooth uključen, uređaj može komunicirati s drugim Bluetooth uređajima u blizini. Funkcije kao što su Quick Share, Pronađi moj uređaj i lokacija uređaja koriste Bluetooth.\n\nAplikacije i usluge i dalje mogu skenirati uređaje u blizini bilo kada, čak i kada je Bluetooth isključen. To se može koristiti, naprimjer, za poboljšanje funkcija i usluga zasnovanih na lokaciji. Ovo možete promijeniti u postavkama Bluetooth skeniranja."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Promijenite"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detalji o uređaju"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Postavke tastature"</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">"Zaboraviti uređaj?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Uklonite povezanost"</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> se neće više povezivati s uređajem <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Eksperimentalno. Poboljšava kvalitet zvuka."</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">"Maksimalni broj povezanih Bluetooth audio uređaja"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Odaberite maksimalan broj povezanih Bluetooth audio uređaja"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Povećaj nivo evidentiranja za NFC grupu"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Povećajte nivo zapisivanja za NFC grupu"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Opširni NFC zapisnik dobavljača o otklanjanju grešaka"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"U izvještaje o greškama uključite dodatne zapisnike dobavljača specifične za uređaj, koji mogu sadržavati privatne podatke."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Nefiltrirani NFC NCI zapisnik"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Snimajte detaljne NFC pakete, koji mogu sadržavati privatne podatke."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Ponovo pokrenuti uređaj?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Detaljno zapisivanje NFC podataka je namijenjeno samo za svrhe programiranja. Dodatni NFC podaci su uključeni u izvještaje o greškama, koji mogu sadržavati privatne podatke. Ponovo pokrenite uređaj da promijenite ovu postavku."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Ponovo pokreni"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Emitiranje"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"preslikavanje"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Omogući bežični prikaz"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Nije pronađen nijedan uređaj u blizini."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Povezuje se"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Povezano"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"U upotrebi"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nedostupan"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opcije Bežičnog prikaza"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Zaboraviti"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Ime"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_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">"Istič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 WiFi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> želi isključiti WiFi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Potvrdi bajtni kôd aplikacija iz kojih se mogu uklanjati greške"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Dopustite ART-u da potvrdi bajtni kôd za aplikacije iz kojih se mogu uklanjati greške"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Prikaži brzinu osvježavanja"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Prikaz trenutne brzine osvježavanja ekrana"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Prikaži omjer HDR/SDR"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Prikaži trenutni omjer HDR/SDR"</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">"Spremno za prijenos sadržaja aplikacije putem NFC-a"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Isključeno"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nije dostupno jer je NFC isključen"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Kada je uključena ova funkcija, možete emitirati sadržaj aplikacije na drugi uređaj koji podržava NFC približavanjem uređaja jedan drugome. Naprimjer, možete emitirati web stranice, videozapise s YouTubea, kontakte i drugo.\n\nSamo približite uređaje jedan drugome (u pravilu, poleđinu uz poleđinu) a zatim dodirnite svoj ekran. Aplikacija će sama prepoznati šta treba emitirati."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"WiFi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Koristi WiFi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"WiFi postavke"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Odaberite WiFi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Uključivanje WiFi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Isključivanje WiFi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Greška"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Opseg od 5 GHz nije dostupan u ovoj zemlji"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"U načinu rada u avionu"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Šalji obavještenja o javnim mrežama"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Obavještava vas kada bude dostupna javna mreža visokog kvaliteta"</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Dozvoli mreže s WEP protokolom"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"WEP protokol je stariji sigurnosni protokol koji je manje siguran"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Operater ne dozvoljava mreže s WEP protokolom jer su manje sigurne"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Automatski uključi WiFi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"WiFi se automatski ponovo uključuje u blizini sačuvanih mreža visokog kvaliteta, kao što je kućna mreža"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nije dostupno jer je lokacija isključena. Uključite "<annotation id="link">"lokaciju"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instaliraj certifikate"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Radi poboljšanja preciznosti lokacije, aplikacije i usluge i dalje mogu skenirati WiFi mreže bilo kada, čak i kada je WiFi isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji. Ovo možete izmijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama Skeniranja WiFi mreže<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Radi poboljšanja preciznosti lokacije, uključite skeniranje WiFi mreža u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama Skeniranja WiFi mreže<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automatsko prebacivanje na prijenos podataka na mobilnoj mreži"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Korištenje prijenosa podataka na mobilnoj mreži kada WiFi mreža nema pristup internetu. Mogu nastati troškovi prijenosa podataka."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Dodajte mrežu"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Postavke za WiFi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"WiFi se uključuje ponovo automatski"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"WiFi se ne uključuje ponovo automatski"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"WiFi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Da biste vidjeli dostupne mreže, uključite WiFi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Pretraživanje mreža…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nemate odobrenje za promjenu WiFi mreže."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Uključiti skeniranje WiFi mreže?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Za automatsko uključivanje WiFi mreže, prvo morate uključiti skeniranje WiFi mreže."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Skeniranje WiFi mreže omogućava aplikacijama i uslugama da traže WiFi mreže u svakom trenutku, čak i kada je WiFi isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Uključi"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Skeniranje WiFi mreže je uključeno"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"Ova mreža koristi stariji sigurnosni protokol koji je manje siguran"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"Mreža <xliff:g id="NAME">%1$s</xliff:g> je blokirana"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"Ova mreža koristi stariji sigurnosni protokol pod nazivom WEP protokol, koji je manje siguran. Da se ipak povežete, možete dozvoliti mreže s WEP protokolom."</string>
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operater vam ne dozvoljava da se povežete s ovom mrežom jer koristi stariji sigurnosni protokol koji je manje siguran"</string>
    <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Dozvoli WEP protokol"</string>
    <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zatvori"</string>
    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
    <skip />
    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
    <skip />
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Napredne opcije"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Padajuća lista Naprednih opcija"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"proširivanje"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Naziv mreže"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Unesite SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sigurnost"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skrivena mreža"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Ukoliko ruter ne emitira ID mreže, ali biste se ubuduće željeli povezati na njega, možete postaviti mrežu kao skrivenu.\n\nNa taj način može biti ugrožena sigurnost jer će telefon redovno emitirati signal da pronađe mrežu.\n\nPostavljenjem mreže kao skrivene neće se promijeniti postavke vašeg rutera."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Jačina signala"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Brzina prijenosa veze"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Brzina primanja veze"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Brzina veze"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvencija"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP adresa"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Sačuvano pomoću"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"<xliff:g id="NAME">%1$s</xliff:g> – vjerodajnice"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP metoda"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"2. faza autentifikacije"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA certifikat"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimalna TLS verzija"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Status online certifikata"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domena"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Korisnički certifikat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identitet"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonimni identitet"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Lozinka"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Prikaži lozinku"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Opseg od 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Preferira se opseg od 5,0 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP postavke"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privatnost"</string>
    <!-- no translation found for wifi_privacy_mac_settings (3188060664478313363) -->
    <skip />
    <!-- no translation found for wifi_privacy_device_name_settings (3699130177041345275) -->
    <skip />
    <!-- no translation found for wifi_privacy_send_device_name_toggle_title (1228107313152880073) -->
    <skip />
    <!-- no translation found for wifi_privacy_send_device_name_toggle_summary (5995365836332817655) -->
    <skip />
    <string name="wifi_subscription" msgid="4432423938285430113">"Pretplata"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Pregledajte ili promijenite pretplatu"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Nasumično odabrani MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Dodajte uređaj"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centrirajte QR kôd ispod da uređaj dodate na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Skenirajte QR kôd"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centrirajte QR kôd ispod da se povežete na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Skenirajte QR kôd da se pridružite WiFi mreži"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Dijeli WiFi mrežu"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Skenirajte ovaj QR kôd pomoću drugog uređaja da se pridružite mreži “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Skenirajte ovaj QR kôd da se povežete s mrežom “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Pokušajte ponovo. Ako se problem ne riješi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Nešto nije uredu"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Provjerite je li uređaj priključen, napunjen i uključen"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Provjerite je li uređaj priključen, napunjen i uključen. Ako se problem ne riješi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Ovaj uređaj ne podržava dodavanje mreže“<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Pokušajte približiti uređaj WiFi pristupnoj tački/ruteru"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Provjerite lozinku i pokušajte ponovo"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Provjerite vezu i pokušajte ponovo"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Odaberite mrežu"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Za povezivanje uređaja, odaberite mrežu"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Dodati ovaj uređaj na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi mreža je podijeljena s uređajem"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Dodaj još jedan uređaj"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Odaberi drugu mrežu"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Uređaj se ne može dodati"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Uređaj je pronađen"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Dijeljenje WiFi mreže s ovim uređajem…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Povezivanje…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Dijeljenje pristupne tačke"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Potvrdite da ste to vi"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Lozinka za WiFi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Lozinka pristupne tačke: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatsko povezivanje"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Dozvolite povezivanje s ovom mrežom kada je u dometu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Dodaj uređaj"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Dodajte uređaj na ovu mrežu pomoću QR koda"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Format QR koda nije važeći"</string>
    <string name="retry" msgid="7542103800274026915">"Pokušaj ponovo"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Dijeli s ostalim korisnicima uređaja"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nepromijenjeno)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Odaberite"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(dodano je više certifikata)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Koristi certifikate sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ne navodi"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Smatraj pouzdanim prilikom prve upotrebe"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Naziv mreže je predug."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Morate navesti domenu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Potreban je certifikat."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Da biste poboljšali preciznost lokacije te u druge svrhe, <xliff:g id="APP_NAME">%1$s</xliff:g> aplikacija želi uključiti skeniranje mreže, čak i kada je WiFi isključen.\n\nŽelite li dozvoliti ovo za sve aplikacije koje žele izvršiti skeniranje?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Da bi poboljšala preciznost lokacije te u druge svrhe, nepoznata aplikacija želi uključiti skeniranje mreže, čak i kada je WiFi isključen.\n\nDozvoliti ovo za sve aplikacije koje žele skenirati?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Dozvoli"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Odbij"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Ova mreža nema pristup internetu. Zadržati povezanost?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Neke aplikacije i usluge možda neće raditi zbog ograničene povezivosti. Ipak koristiti?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ne pitaj me više za ovu mrežu"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"WiFi mreža nije povezana na internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Možete se prebaciti na mobilnu mrežu kad god je Wi‑Fi veza loša. Mogu nastati troškovi prijenosa podataka."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Prebaci na mobilnu mrežu"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Ostani na WiFi mreži"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Nemoj više prikazivati"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Poveži se"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Povezano s mrežom <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Povezivanje…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Povezivanje na mrežu nije uspjelo"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Mreža nije u dometu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Zaboravi"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Izmijeni"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Sačuvaj"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Čuvanje mreže nije uspjelo"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Otkaži"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Zaboraviti mrežu?"</string>
    <string name="wifi_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čno odabrana MAC adresa (zadnje korišteno)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detalji o mreži"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podmreže"</string>
    <string name="wifi_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="hotspot_device_details_category" msgid="3110651914598697220">"Detalji o uređaju s pristupnom tačkom"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Izvor interneta"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"WiFi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> – punjenje"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Veza pristupne tačke"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Jačina veze"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Sačuvane mreže"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Pretplate"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Druge mreže"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Unesite važeću IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Unesite važeću adresu pristupnika."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Unesite važeću DNS adresu."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Unesite dužinu mrežnog prefiksa između 0 i 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (osim ako ga nije poništio privatni DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (osim ako ga nije poništio privatni DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Pristupnik"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Dužina prefiksa mreže"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"WiFi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Potraži uređaje"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Pretraživanje…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Promijeni naziv uređaja"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Ravnopravni uređaji"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Zapamćene grupe"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Povezivanje nije uspjelo."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Promjena naziva uređaja nije uspjela."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Prekinuti vezu?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Ako prekinete vezu, okončat će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Ako prekinete vezu, okončat će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g> i još <xliff:g id="PEER_COUNT">%2$s</xliff:g> uređaja."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Otkazati pozivnicu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Da li želite otkazati pozivnicu za povezivanje s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Zaboraviti ovu grupu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"WiFi pristupna tačka"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Nema dijeljenja interneta ili sadržaja s drugim uređajima"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Lozinka nije postavljena"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Naziv pristupne tačke"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Lozinka pristupne tačke"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Automatski isključi pristupnu tačku"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kada nijedan uređaj nije povezan"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Proširi kompatibilnost"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Pomaže ostalim uređajima da pronađu ovu pristupnu tačku. Smanjuje brzinu povezivanja pristupne tačke."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Pomaže ostalim uređajima da pronađu ovu pristupnu tačku. Povećava potrošnju baterije."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Brzina i kompatibilnost"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / kompatibilno je s većinom uređaja"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / kompatibilno je s mnogim uređajima"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / kompatibilno je s manje uređaja"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 i 5 GHz / kompatibilne su s većinom uređaja"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Odaberite frekvenciju za pristupnu tačku. Frekvencija utiče ne brzinu veze i vrste uređaja koje mogu pronaći pristupnu tačku."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Željena frekvencija"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Manje brzine. Kompatibilne su s većinom uređaja."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Velike brzine. Kompatibilne su s mnogim uređajima."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 i 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Velike brzine. Ova dvopojasna pristupna tačka je kompatibilna s većinom uređaja."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Najveće brzine. Kompatibilne su s manje uređaja."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nije dostupno u vašoj zemlji ili regiji"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Ako željena frekvencija nije dostupna, pristupna tačka može koristiti drugu frekvenciju. Postavke sigurnosti pristupne tačke se mogu promijeniti ako promijenite frekvenciju."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nije dostupno uz 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Postavke sigurnosti se mogu promijeniti ako promijenite frekvenciju pristupne tačke"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Instant pristupna tačka"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Uključeno"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Isključeno"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Uključivanje pristupne tačke…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Isključivanje pristupne tačke…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Dijeljenje internetske veze nije dostupno"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Za detalje se obratite mobilnom operateru"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivna"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Android pristupna tačka"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Sačuvati ovu mrežu?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Pohranjivanje…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Sačuvano"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Nije moguće sačuvati. Pokušajte ponovo."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Sačuvati mreže?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Čuvanje mreža (<xliff:g id="NUMBER">%d</xliff:g>)…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Mreže su sačuvane"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Proširite mogućnost pozivanja s Wi‑Fi-jem"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Uključite pozivanje putem Wi‑Fi-ja za veću pokrivenost"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Postavka poziva"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Postavka pozivanja"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Postavke rominga"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Postavke rominga"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"WiFi"</item>
    <item msgid="8622872038388687383">"Mobilna mreža"</item>
    <item msgid="3027927219952052398">"Samo WiFi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"WiFi"</item>
    <item msgid="7566603075659706590">"Mobilna mreža"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Ako WiFi nije dostupan, koristi mobilnu mrežu"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Ako mobilna mreža nije dostupna, koristi WiFi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Pozivanje putem WiFi-ja. Ako se izgubi WiFi, poziv će se prekinuti."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kada je opcija Pozivanje putem WiFi-ja uključena, telefon može preusmjeravati pozive putem WiFi mreža ili mreže vašeg operatera, u zavisnosti od toga kakve su vaše postavke i koji signal je jači. Prije nego što uključite ovu funkciju, raspitajte se o naknadi i drugim informacijama kod operatera.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Adresa za hitne slučajeve"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Koristi se kao vaša lokacija prilikom hitnog poziva putem Wi‑Fi mreže"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Saznajte više"</annotation>" o funkcijama privatnog DNS-a"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Uključeno"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivirajte pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Uključite pozivanje putem WiFi-ja"</string>
    <string name="wifi_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 radnog profila – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Računi ličnog profila"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Računi kloniranih profila"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Račun za Work – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Lični račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Pretražite"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ekran"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automatsko rotiranje ekrana"</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 osnovu 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 rotiranju"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Rezolucija ekrana"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Visoka rezolucija"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Puna rezolucija"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Puna rezolucija troši više baterije. Prebacivanje rezolucije može uzrokovati ponovo 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">"Prirodne"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Pojačane"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Zasićene"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Prilagodljive"</string>
    <string name="brightness" msgid="6216871641021779698">"Nivo osvjetljenja"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Prilagodljiva osvijetljenost"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Osvijetljenost ekrana će se automatski prilagođavati vašem okruženju i aktivnostima. Klizač možete ručno pomjerati kako bi prilagodljiva osvijetljenost zapamtila vaše postavke."</string>
    <string name="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">"Balans bijele boje prikaza"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Nastavak korištenja aplikacija nakon sklapanja"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Onemogući zadani br. sl. u s za igre"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Onemogućite ograničavanje maksimalnog broja slika u sekundi za igre pri <xliff:g id="FRAME_RATE">%1$d</xliff:g> Hz."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"Glatki prikaz"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Automatski podiže učestalost osvježavanja do <xliff:g id="ID_1">%1$d</xliff:g> Hz za određeni sadržaj. Povećava potrošnju baterije."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Nametni maksimalnu brzinu osvježavanja"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Najveća brzina osvježavanja za poboljšanu reakciju na dodir i kvalitet animacije. Povećava potrošnju baterije."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Svjesni ekran"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Potreban je pristup kameri"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Za svjesni ekran je potreban pristup kameri. Dodirnite da upravljate odobrenjima za Usluge personalizacije uređaja"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Upravljajte odobrenjima"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Sprečava isključivanje ekrana ako gledate u njega"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Funkcija Svjesni ekran koristi prednju kameru da utvrdi gleda li neko u ekran. Funkcionira na uređaju, a slike se nikada ne arhiviraju niti šalju Googleu."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Uključite svjesni ekran"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Zadržava ekran uključenim dok gledate u njega"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Duži istek vremena ekrana će povećati potrošnju baterije."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera je zaključana"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Kamera se mora otključati za Prepoznavanje lica"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Morate otključati kameru za Svjesni ekran"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Pristup kameri je obavezan za prepoznavanje lica. Dodirnite da upravljate odobrenjima za Usluge personalizacije uređaja"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Upravljajte odobrenjima"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Noćno svjetlo"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Noćno svjetlo oboji ekran u žutosmeđe. Tako je lakše gledati u ekran ili čitati pod prigušenim svjetlom, a može vam pomoći da lakše zaspite."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Raspored"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Ništa"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Uključuje se u zadano vrijeme"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Uključeno od sumraka do svitanja"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Vrijeme početka"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Vrijeme završetka"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intenzitet"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Neće se nikada automatski uključiti"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Automatski će se uključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Automatski će se uključiti u sumrak"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Neće se nikada automatski isključiti"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Automatski će se isključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Automatski će se isključiti u svitanje"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Noćno svjetlo nije uključeno"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Da bi se odredio zalazak i izlazak sunca, potrebna je lokacija uređaja."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Postavke lokacije"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Uključi sada"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Isključi sada"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Uključi do izlaska sunca"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Isključi do zalaska sunca"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Način rada po mraku"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Raspored"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Ništa"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Uključeno od sumraka do svitanja"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Uključuje se u zadano vrijeme"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Uključuje se u vrijeme za spavanje"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Neće se nikada automatski uključiti"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Automatski će se uključiti u sumrak"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Automatski će se uključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Uključit će se automatski u vrijeme za spavanje"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Neće se nikada automatski isključiti"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Automatski će se isključiti u svitanje"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Automatski će se isključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Isključit će se automatski nakon vremena za spavanje"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tamna tema koristi crnu pozadinu radi produženja trajanja baterije. Rasporedi tamne teme čekaju s uključivanjem dok se ekran ne isključi."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tamna tema trenutno prati vaš raspored načina rada za spavanje"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Postavke načina rada za spavanje"</string>
    <!-- no translation found for even_dimmer_display_title (8589063452814896327) -->
    <skip />
    <!-- no translation found for even_dimmer_display_summary (120301078873242172) -->
    <skip />
    <string name="screen_timeout" msgid="7709947617767439410">"Istek vremena ekrana"</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">"Pozadinska slika i stil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Početni ekran, zaključani ekran"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Promijenite pozadinsku sliku"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Prilagodite svoj ekran"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Odabir pozadinske slike iz"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Prilagodite telefon"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Isprobajte različite stilove, pozadinske slike i još mnogo toga"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Čuvar ekrana"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"čuvar ekrana"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nedostupno jer je uključen način rada za spavanje"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Koristi čuvar ekrana"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Tokom punjenja ili kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Dok je uređaj priključen i puni se"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Tokom punjenja"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nikada"</string>
    <string name="screensaver_settings_summary_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 početi"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Podignite za buđenje"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambijentalni prikaz"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kada prikazati"</string>
    <string name="doze_title" msgid="1523090408230862316">"Aktiviraj ekran za obavještenja"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kada je ekran zatamnjen, uključuje se zbog novih obavještenja"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Uvijek prikaži vrijeme i 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čaj SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Promjena PIN-a SIM kartice"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN za SIM"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Zaključaj SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Otključaj SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Stari PIN za SIM"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Novi PIN za SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Ponovo unesite novi PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN za SIM"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Unesite PIN koji sadržava 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">"PIN za SIM uspješno promijenjen"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Onemogućavanje PIN-a nije uspelo."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Omogućavanje PIN-a nije uspelo."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Uredu"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Otkaži"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Koristiti <xliff:g id="CARRIER">%1$s</xliff:g> za mobilne podatke?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Koristite <xliff:g id="CARRIER2_0">%2$s</xliff:g> za prijenos podataka na mobilnoj mreži. Ako se prebacite na operatera <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> se više neće koristiti za prijenos podataka na mobilnoj mreži."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Koristi <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Ažurirati preferirani 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 taj SIM koristiti za prijenos podataka na mobilnoj mreži, pozive i SMS poruke?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Poboljšati pokrivenost prijenosa pod.?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Dozvolite uređaju da se automatski prebaci na operatera <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> za prijenos podataka na mobilnoj mreži kada ima bolju dostupnost."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Pozivi, poruke i mrežni saobraćaj mogu biti vidljivi vašoj organizaciji."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"PIN za SIM je netačan. Za otključavanje uređaja sada morate kontaktirati svog operatera."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{PIN kôd za SIM je netačan. Imate još # pokušaj prije nego što budete morali kontaktirati mobilnog operatera da vam otključa uređaj.}one{PIN kôd za SIM je netačan. Imate još # pokušaj.}few{PIN kôd za SIM je netačan. Imate još # pokušaja.}other{PIN kôd za SIM je netačan. Imate još # pokušaja.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"PIN kôd za SIM je netačan. Imate još 1 pokušaj prije nego što budete morali kontaktirati operatera da bi otključao uređaj."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operacija PIN-a za SIM nije uspjela!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Ažuriranja sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Verzija Androida"</string>
    <string name="security_patch" msgid="4071756145347865382">"Sigurnosno ažuriranje za Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Verzija hardvera"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Godina proizvodnje"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID opreme"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Verzija nemoduliranog signala"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Osnovna verzija"</string>
    <string name="build_number" msgid="9009733242117579826">"Broj verzije"</string>
    <string name="module_version" msgid="1787518340082046658">"Ažuriranje sistema Google Playa"</string>
    <string name="battery_info" msgid="7873528123969546728">"Informacije o bateriji"</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 keš memorija"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Postavke za pohranu"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (utor SIM-a <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">"Za prikaz odaberite sačuvanu mrežu"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Verzija PRL-a"</string>
    <string name="meid_multi_sim" msgid="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 mreže za prijenos podataka"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Vrsta mreže za glasovne pozive"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informacije o operateru"</string>
    <string name="status_data_state" msgid="525196229491743487">"Stanje mobilne mreže"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Stanje usluge"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Jačina signala"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Mreža"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"MAC adresa WiFi-ja"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"MAC adresa uređaja za WiFi"</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="battery_manufacture_date" msgid="7139426520156833987">"Datum proizvodnje"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Datum prve upotrebe"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Broj ciklusa"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Nedostupno"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Računanje…"</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Promijeni naziv"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Montiraj"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Izbaci"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatiraj SD karticu za prenosivu pohranu"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatiraj karticu"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatiraj kao prenosivu"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatiraj"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Prenesi podatke"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Zaboraviti"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Postavi"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Oslobodite prostor"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Upravljajte pohranom"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Oslobodite prostor"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Idite u aplikaciju Files da upravljate i oslobodite prostor"</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">"<xliff:g id="NAME">%1$s</xliff:g> je priključen"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Nije se mogao montirati <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je sigurno izbačen"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> se ne može sigurno izbaciti"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Promjena naziva pohrane"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Ovaj <xliff:g id="NAME_0">^1</xliff:g> je oštećen. \n\nDa biste koristili ovaj <xliff:g id="NAME_1">^1</xliff:g>, najprije ga morate postaviti."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Možete formatirati ovu SD karticu da pohranjujete fotografije, videozapise, muziku i drugo te im pristupate na drugim uređajima. \n\n"<b>"Svi podaci na SD kartici će se potpuno izbrisati."</b>" \n\n"<b>"Prije formatiranja"</b>" \n\n"<b>"Napravite sigurnosne kopije fotografija i drugog medijskog sadržaja"</b>" \nPremjestite medijske fajlove u alternativnu pohranu na ovom uređaju ili ih prenesite na računar pomoću USB kabla. \n\n"<b>"Napravite sigurnosne kopije aplikacija"</b>" \nSve aplikacije koje se nalaze na mediju <xliff:g id="NAME">^1</xliff:g> će se deinstalirati, a njihovi podaci potpuno izbrisati. Da zadržite te aplikacije, premjestite ih u alternativnu pohranu na ovom uređaju."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Kada izbacite ovaj uređaj (<xliff:g id="NAME_0">^1</xliff:g>), aplikacije pohranjene na njemu će prestati radit, a medijski fajlovi pohranjeni na njemu neće biti dostupni dok ga ponovo ne umetnete."</b>" \n\nUređaj <xliff:g id="NAME_1">^1</xliff:g> je formatiran tako da funkcionira samo na ovom uređaju. Neće funkcionirati ni na jednom drugom uređaju."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Da biste koristili aplikacije, slike ili podatke koje ovaj uređaj (<xliff:g id="NAME">^1</xliff:g>) sadrži, ponovo ga umetnite. \n\nUmjesto toga, možete odabrati da zaboravite ovu memoriju ukoliko uređaj nije dostupan \n\nAko odaberete da zaboravite memoriju, svi podaci koje uređaj sadrži će zauvijek biti izgubljeni \n\nAplikacije možete kasnije ponovo instalirati, ali njihovi podaci pohranjeni na ovom uređaju će biti izgubljeni."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Zaboraviti uređaj <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Sve aplikacije, fotografije i podaci pohranjeni na ovom <xliff:g id="NAME">^1</xliff:g> bit će trajno izgubljeni."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sistem obuhvata fajlove koji se koriste za pokretanje verzije Androida <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Korisnici gosti ne mogu formatirati SD kartice"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatiranje <xliff:g id="NAME">^1</xliff:g>..."</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Nemojte uklanjati pohranu <xliff:g id="NAME">^1</xliff:g> dok se formatira."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"Medij <xliff:g id="NAME">^1</xliff:g> je formatiran"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Premjesti <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Premještanje <xliff:g id="APP">^1</xliff:g> i njenih podataka na <xliff:g id="NAME_0">^2</xliff:g> će trajati samo nekoliko trenutaka. Nećete biti u mogućnosti koristiti aplikacije sve dok se ne završi premještanje. \n\n Nemojte uklanjati <xliff:g id="NAME_1">^2</xliff:g> tokom premještanja."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Da prebacite podatke, morate otključati korisnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Premješta se <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Nemojte uklanjati <xliff:g id="NAME">^1</xliff:g> tokom premještanja. Aplikacija \n\n <xliff:g id="APP">^2</xliff:g> na ovom uređaju neće biti dostupna sve dok se ne završi premještanje."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Kako ćete koristiti pohranu <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">"Formatirajte SD karticu za prenosivu pohranu"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Pohranite fotografije, videozapise, muziku i još mnogo toga te im pristupite 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">"Da pohranjujete aplikacije, fajlove i medije, potrebno je formatirati medij <xliff:g id="NAME_0">^1</xliff:g>. \n\nFormatiranjem se potpuno briše postojeći sadržaj medija <xliff:g id="NAME_1">^2</xliff:g>. Da ne izgubite sadržaj, napravite sigurnosnu kopiju na drugi medij <xliff:g id="NAME_2">^3</xliff:g> ili uređaj."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Da pohranjujete fotografije, videozapise, muziku i drugo, potrebno je formatirati medij <xliff:g id="NAME_0">^1</xliff:g>. \n\nFormatiranjem će se potpuno izbrisati postojeći sadržaj na mediju <xliff:g id="NAME_1">^2</xliff:g>. Da ne izgubite sadržaj, napravite sigurnosne kopije podataka na drugom mediju <xliff:g id="NAME_2">^3</xliff:g> ili uređaju."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Format. pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Premjestiti sadržaj na: <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Tokom premještanja:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Nemojte uklanjati pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Neke aplikacije neće raditi"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Premjesti sadržaj"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Premjesti sadržaj kasnije"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Premještanje sadržaja…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Spora pohrana <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"I dalje možete koristiti uređaj <xliff:g id="NAME_0">^1</xliff:g>, ali može biti spor. \n\nAplikacije pohranjene na uređaju za pohranu <xliff:g id="NAME_1">^2</xliff:g> možda neće raditi ispravno, a prijenos sadržaja može dugo trajati. \n\nPokušajte koristiti brži uređaj za pohranu <xliff:g id="NAME_2">^3</xliff:g> ili koristite ovaj uređaj <xliff:g id="NAME_3">^4</xliff:g> kao prenosivu pohranu."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Počni ispočetka"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Nastavi"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Možete početi koristiti medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Možete početi koristiti medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Možete početi koristiti 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">"Nivo napunjenosti baterije"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Opće"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Opće postavke"</string>
    <string name="satellite_setting" msgid="706846910912477125">"Satelitska razmjena poruka"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN-ovi"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Uredi pristupnu tačku"</string>
    <string name="apn_add" msgid="9069613192201630934">"Dodajte pristupnu tačku"</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">"Proksi"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Priključak"</string>
    <string name="apn_user" msgid="5831763936428279228">"Korisničko ime"</string>
    <string name="apn_password" msgid="7435086635953953029">"Lozinka"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS proksi"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS priključak"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Vrsta autentifikacije"</string>
    <string name="apn_type" msgid="1835573305077788773">"Vrsta APN-a"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol APN-a"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol APN-a za roming"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Omogući/onemogući APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN omogućen"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN onemogućen"</string>
    <string name="bearer" msgid="3231443241639159358">"Nosilac"</string>
    <string name="network_type" msgid="748590707422733595">"Vrsta mreže"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Neodređeno"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO vrsta"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO vrijednost"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Izbriši APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Novi APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Sačuvaj"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Otkaži"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_duplicate_apn_entry" msgid="7792928408935276618">"Duplikat APN unosa."</string>
    <string name="error_name_empty" msgid="1258275899283079142">"Polje Ime ne može ostati prazno."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Naziv pristupne tačke ne može biti prazan."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC polje mora imati 3 cifre."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC polje mora imati 2 ili 3 cifre."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operater ne dozvoljava dodavanje APN-a tipa %s."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"MMSC polje mora biti važeće."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Vraćanje zadanih postavki za APN."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Vrati na zadano"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Vraćanje zadanih postavki za APN je završeno."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Opcije vraćanja na zadano"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Vrati postavke mobilne mreže na zadano"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Ovim će se vratiti na zadano sve postavke mobilne mreže"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Poništiti postavke mobilne mreže?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Vratite Bluetooth i WiFi na zadano"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Ovo će vratiti sve zadane postavke WiFi-ja i Bluetootha. Ovu radnju ne možete opozvati."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Vrati na zadano"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth i WiFi su vraćeni na zadano"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Potpuno izbriši eSIM-ove"</string>
    <string name="reset_esim_desc" msgid="6125192435907740751">"Ovim se neće otkazati paket mobilne usluge. Da dobijete zamjenski SIM, kontaktirajte operatera."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Vrati postavke na zadano"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Vratiti sve postavke mreže na zadano? Ovu radnju ne možete opozvati."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Vratiti sve postavke mreže na zadano i potpuno izbrisati eSIM-ove? Ovu radnju ne možete opozvati."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Vrati postavke na zadano"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Vratiti na zadano?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Ponovno postavljanje mreže nije dostupno za ovog korisnika"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Postavke mreže vraćene su na zadano"</string>
    <string name="reset_esim_error_title" msgid="6516110227665862295">"Nije moguće potpuno izbrisati podatke na eSIM-ovima"</string>
    <string name="reset_esim_error_msg" msgid="8459527827897797168">"Nešto nije uredu i podaci na eSIM-ovima nisu potpuno izbrisani.\n\nPonovo pokrenite uređaj i pokušajte ponovo."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Izbriši sve podatke (vraćanje na fabričke postavke)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Izbriši sve podatke"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"muziku"</li>\n<li>"fotografije"</li>\n<li>"ostale korisničke podatke"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM-ove"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Ovim se neće otkazati vaš plan usluga mobilnog operatera."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Izbrisat će se svi vaši lični podaci i preuzete aplikacije. Ovu radnju ne možete poništiti."</string>
    <string name="main_clear_final_desc_esim" msgid="6592404057237813989">"Izbrisat će se sve vaše lične informacije, uključujući preuzete aplikacije i eSIM-ove. Ovu radnju ne možete opozvati."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Potpuno izbrisati sve podatke?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Vraćanje na fabričke postavke nije dostupno za ovog korisnika"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Brisanje"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Pričekajte…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Postavke poziva"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Postavite govornu poštu, prosljeđivanje poziva, poziv na čekanju, ID pozivaoca"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Dijeljenje internetske veze putem USB-a"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Prijenosna pristupna tačka"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Dijeljenje internetske veze putem Bluetootha"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Dijeljenje internetske veze"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Pristupna tačka i dijeljenje internetske veze"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Pristupna tačka je uključena, dijeljenje internetske veze"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Pristupna tačka je uključena"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Dijeljenje internetske veze"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Dok je upaljena Ušteda podataka nije moguće povezati uređaj niti koristiti prijenosne pristupne tačke"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Samo pristupna tačka"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Samo USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Samo Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Samo Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Pristupna tačka, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Pristupna tačka, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Pristupna tačka, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Pristupna tačka, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Pristupna tačka, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Pristupna tačka, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Pristupna tačka, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internet se ne dijeli s drugim uređajima"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Isključeno"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Dijeljenje internetske veze putem USB-a"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Dijeljenje internetske veze putem Bluetootha"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Dijeljenje internetske veze putem Etherneta"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Koristite pristupnu tačku i Dijeljenje internetske veze da omogućite internet drugim uređajima putem veze za prijenos podataka na mobilnoj mreži. Aplikacije također mogu kreirati pristupne tačke za dijeljenje sadržaja s uređajima u blizini."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Koristite pristupnu tačku i dijeljenje internetske veze da omogućite internet drugim uređajima putem WiFi-ja ili prijenosa podataka na mobilnoj mreži. Aplikacije također mogu kreirati pristupne tačke za dijeljenje sadržaja s uređajima u blizini."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pomoć"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilna mreža"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikacija za SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Promijeniti aplikaciju za SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Koristiti <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Koristiti <xliff:g id="NEW_APP">%s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Promijeniti WiFi asistenta?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Želite li koristiti aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Koristiti <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje vašim mrežnim vezama?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavni zahtjevi za lokaciju"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za radni profil"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Odobrenja 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} aplik. ima pristup lokaciji}one{# od {total} aplik. imaju pristup lokaciji}few{# od {total} aplik. imaju pristup lokaciji}other{# od {total} aplik. 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">"Prikaži sve"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Prikaži detalje"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Nijedna aplikacija nije nedavno zahtijevala lokaciju"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Nijedna aplikacija nije nedavno pristupila lokaciji"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Visoka potrošnja baterije"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Niska potrošnja baterije"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Skeniranje WiFi-ja"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Dozvolite aplikacijama i uslugama da skeniraju WiFi mreže u svakom trenutku, čak i kada je WiFi isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Skeniranje Bluetootha"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Dozvolite aplikacijama i uslugama da skeniraju uređaje u blizini u svakom trenutku, čak i kada je Bluetooth isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="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">"Lokacija ili usluge lokacije su isključene"</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 postavite vremensku zonu pomoću 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 ovo"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Otkaži"</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">"Otkrivanje vremenske zone pomoću lokacije je onemogućeno"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Otkrivanje vremenske zone pomoću lokacije nije podržano"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Promjene otkrivanja vremenske zone pomoću lokacije nisu dozvoljene"</string>
    <string name="location_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">"Ručno"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulatorne oznake"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Priručnik za sigurnost i propise"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autorska prava"</string>
    <string name="license_title" msgid="8745742085916617540">"Licenca"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licence za ažuriranje sistema Google Playa"</string>
    <string name="terms_title" msgid="2071742973672326073">"Uslovi i odredbe"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Sistemske WebView licence"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Zahvale za pozadinske slike"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Pružaoci satelitskih slika:\n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Ručno"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Došlo je do problema sa učitavanjem priručnika."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licence trećih strana"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Pojavio se problem s učitavanjem licenci."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Učitavanje…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Učitavanje…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Postavite lozinku"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Postavite lozinku radnog 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 radnog profila"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Postavite uzorak"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Radi dodatne sigurnosti postavite uzorak za otključavanje uređaja"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Postavite uzorak radnog profila"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Da koristite otisak prsta, postavite lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Da koristite otisak prsta, postavite uzorak"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Postavite PIN radi sigurnosti"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Da koristite otisak prsta, postavite PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Ponovo unesite lozinku"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Ponovo unesite lozinku radnog profila"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Unesite radnu lozinku"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potvrdite uzorak"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Unesite radni uzorak"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Ponovo unesite PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Ponovo unesite PIN radnog profila"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Unesite radni PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Lozinke se ne podudaraju"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN-ovi se ne podudaraju"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Ponovo nacrtajte uzorak"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Vrste otključavanja"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Lozinka je postavljena"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN je postavljen"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Uzorak je postavljen"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Za otključavanje licem postavite lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Za otključavanje licem postavite uzorak"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Za otključavanje licem postavite PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Postavite lozinku da koristite lice ili otisak prsta"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Postavite uzorak da koristite lice ili otisak prsta"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Postavite PIN da koristite lice ili otisak prsta"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Zaboravili ste lozinku?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Zaboravili ste uzorak?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Zaboravili ste PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Nacrtajte obrazac da nastavite"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Unesite PIN da nastavite"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Unesite lozinku da nastavite"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Nacrtajte obrazac radnog profila da nastavite"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Unesite radni PIN da nastavite"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Za nastavak, unesite radnu lozinku."</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Za dodatnu sigurnost, unesite uzorak uređaja"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Za dodatnu sigurnost, unesite PIN uređaja"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Za dodatnu sigurnost, unesite lozinku uređaja"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Za dodatnu sigurnost, unesite radni uzorak"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Za dodatnu sigurnost, unesite radni PIN"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Za dodatnu sigurnost, unesite radnu lozinku"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Potvrdite obrazac"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Potvrdite PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Potvrdite lozinku"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Potvrdite identitet"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Da prenesete Google račune, postavke i drugo, unesite uzorak drugog uređaja. Uzorak je šifriran."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Da prenesete 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 prenesete Google račune, postavke i drugo, unesite lozinku drugog uređaja. Lozinka je šifrirana."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Koristi i uzorak za otključavanje uređaja"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Koristi i PIN za otključavanje uređaja"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Koristi i lozinku za otključavanje uređaja"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Potvrdite uzorak"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Potvrdite PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Potvrdite lozinku"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Unesite uzorak za uređaj da nastavite"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Unesite PIN za uređaj da nastavite"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Unesite lozinku za uređaj da nastavite"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Pogrešan PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Pogrešna lozinka"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Pogrešan uzorak"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Hitan slučaj"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Sigurnost uređaja"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Promijeni uzorak za otključavanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Promijeni PIN za otključavanje"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Nacrtajte uzorak za otključavanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Pritisnite Meni za pomoć."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Podignite prst kada završite"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Povežite najmanje <xliff:g id="NUMBER">%d</xliff:g> tačke. Pokušajte ponovo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Uzorak je snimljen"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Ponovo nacrtajte uzorak da potvrdite"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Novi uzorak za otključavanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potvrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Nacrtaj ponovo"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Obriši"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Nastavi"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Uzorak za otključavanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Zahtijevaj uzorak"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Mora se nacrtati uzorak za otključavanje ekrana"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Učini uzorak vidljivim"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Poboljšana privatnost PIN-a"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Onemogućite animacije tokom unosa PIN-a"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Neka uzorak profila bude vidljiv"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibracija na dodir"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Dugme za uključiv. zaključava"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Osim kada ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> drži otključanim"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Postavi uzorak otključavanja"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Promijeni uzorak za otključavanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kako nacrtati uzorak za otključavanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Previše pogrešnih pokušaja. Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikacija nije instalirana na vašem telefonu."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Sigurnost radnog profila"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zaključavanje ekrana radnog profila"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Koristite jedno zaključavanje za radni profil i ekran uređaja"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Želite li koristiti jedno zaključavanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Uređaj će koristiti zaključavanje ekrana vašeg radnog profila. Pravila za rad će se primjenjivati za oba tipa zaključavanja."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Zaključavanje vašeg radnog profila ne ispunjava sigurnosne zahtjeve vaše organizacije. Možete koristiti isto zaključavanje za ekran uređaja i radnog profila, ali važit će sve postavke zaključavanja radnog profila."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Isto kao i zaključavanje ekrana uređaja"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Upravljaj aplikacijama"</string>
    <string name="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 otvarane aplikacije"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Pogledajte sve aplikacije}one{Pogledajte sve aplikacije (njih #)}few{Pogledajte sve aplikacije (njih #)}other{Pogledajte sve aplikacije (njih #)}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontaktirajte IT administratora"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Može vam pomoći s poništavanjem PIN-a, uzorka ili lozinke"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Napredne postavke"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Omogućite više opcija postavki"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Informacije o aplikaciji"</string>
    <string name="storage_label" msgid="2522307545547515733">"Pohrana"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Zadano otvaranje"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Zadane vrijednosti"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilnost ekrana"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Odobrenja"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Keš memorija"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Obriši keš memoriju"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Keš memorija"</string>
    <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">"Pristup je slobodan"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontrole"</string>
    <string name="force_stop" msgid="2681771622136916280">"Prisilno zaustavi"</string>
    <string name="archive" msgid="9074663845068632127">"Arhiviraj"</string>
    <string name="restore" msgid="7622486640713967157">"Vrati"</string>
    <string name="restoring_step_one" msgid="3465050101254272874">"Vraćanje"</string>
    <string name="restoring_step_two" msgid="140484846432595108">"Vraćanje."</string>
    <string name="restoring_step_three" msgid="3712883580876329811">"Vraćanje…"</string>
    <string name="restoring_step_four" msgid="8966846882470446209">"Vraćanje…"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Ukupno"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Veličina aplikacije"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikacija USB pohrane"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Korisnički podaci"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Deinstaliraj"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Deinstaliraj za sve korisnike"</string>
    <string name="install_text" msgid="4558333621516996473">"Instaliraj"</string>
    <string name="disable_text" msgid="5146002260857428005">"Onemogući"</string>
    <string name="enable_text" msgid="8570798764647110430">"Omogući"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Obriši pohranu"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Deinstaliraj ažuriranja"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Dozvoli ograničene postavke"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Određene aktivnosti koje ste odabrali se otvaraju u ovoj aplikaciji prema zadanim postavkama."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Odabrali ste da ovoj aplikaciji dodijelite odobrenje za kreiranje vidžeta i pristup njihovim podacima."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nisu postavljene zadane vrijednosti."</string>
    <string name="clear_activities" msgid="488089228657585700">"Obriši zadane postavke"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Ova aplikacija možda nije dizajnirana za vaš ekran. Ovdje možete odrediti kako se ona prilagođava vašem ekranu."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Pitaj prilikom pokretanja"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skaliraj aplikaciju"</string>
    <string name="unknown" msgid="8192160131923461175">"Nepoznato"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Poredaj po imenu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Poredaj po veličini"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Najskorije"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Najčešće"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Prikaži pokrenute usluge"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Prikaži procese iz keš memorije"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikacija za hitne situacije"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Vrati postavke aplikacije na zadano"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Vratiti postavke aplikacije na zadano?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Ovim će se vratiti sve postavke na zadano za:\n\n"<li>"onemogućene aplikacije"</li>\n<li>"obavještenja za onemogućene aplikacije"</li>\n<li>"zadane aplikacije za radnje"</li>\n<li>"ograničenja pozadinskih podataka za aplikacije"</li>\n<li>"sva ograničenja za odobrenja"</li>\n<li>"postavke korištenja baterije"</li>\n\n"Nećete izgubiti podatke iz aplikacija."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Vrati aplikacije na zadano"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Odaberite opcije filtera"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Sve aplikacije"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Onemogućene aplikacije"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Preuzeto"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Pokretanje"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nije instal. za ovog korisnika"</string>
    <string name="installed" msgid="2837449358488825884">"Instalirano"</string>
    <string name="no_applications" msgid="985069304755391640">"Nema aplikacija."</string>
    <string name="internal_storage" msgid="999496851424448809">"Unutrašnja pohrana"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Ponovno izračunavanje veličine…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Izbrisati podatke aplikacije?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Podaci ove aplikacije, uključujući fajlove i postavke, trajno će se izbrisati s ovog uređaja."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Uredu"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Otkaži"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Izbriši"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikacija nije pronađena na listi instaliranih aplikacija."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Pohrana za aplikaciju nije obrisana."</string>
    <string name="computing_size" msgid="4915310659841174866">"Računanje…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nije bilo moguće izračunati veličinu paketa."</string>
    <string name="version_text" msgid="7628938665256107608">"verzija <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Premjesti"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Arhiviranje nije uspjelo"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"Arhivirano: <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Vraćanje nije uspjelo"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Vraćanje aplikacije <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Druga migracija je već u toku."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nema dovoljno prostora za pohranu."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikacija ne postoji."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Lokacija instaliranja nije važeća."</string>
    <string name="system_package" msgid="7559476279008519360">"Ažuriranja sistema se ne mogu instalirati na vanjske medijume."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikaciju administratora uređaja nije moguće instalirati na vanjski medij"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Prisilno zaustaviti?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Ako prisilno zaustavite aplikaciju, moguće je da će se ponašati nepredviđeno."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Onemogući aplikaciju"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ako onemogućite ovu aplikaciju, moguće je da Android i druge aplikacije više neće funkcionirati ispravno. Vodite računa da ovu aplikaciju ne možete izbrisati jer je unaprijed instalirana na vašem uređaju. Ako onemogućite, isključit ćete ovu aplikaciju i sakriti je na uređaju."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Trgovina"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detalji o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikacija je instalirana iz: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Više informacija na <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Pokrenuto"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nikad korišteno)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Korištenje pohrane"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Ponovno pokretanje"</string>
    <string name="cached" msgid="5379485147573438201">"Keširani procesi u pozadini"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Ništa nije pokrenuto."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Pokrenula aplikacija."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Slobodno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Iskorišteno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Korisnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Uklonjen korisnik"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluge/a"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces/a i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces/a i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluge/a"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memorija uređaja"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Iskorištenost RAM-a aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Slobodno"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Iskorišteno"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Keširano"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Pokrenuta aplikacija"</string>
    <string name="no_services" msgid="3898812785511572899">"Nije aktivno"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Usluge"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesi"</string>
    <string name="service_stop" msgid="5712522600201308795">"Zaustavi"</string>
    <string name="service_manage" msgid="3896322986828332075">"Postavke"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Ovu uslugu je pokrenula njena aplikacija. Zaustavljanje može izazvati prekid rada aplikacije."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Ovu aplikaciju nije moguće zaustaviti na siguran način. Ako je zaustavite mogli biste izgubiti dio sadržaja na kome trenutno radite."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Ovo je stari aplikacijski proces ostavljen u funkciji za slučaj da zatreba. Obično nema razloga za njegovo zaustavljanje."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutno je u upotrebi. Dodirnite Postavke da kontrolirate uslugu."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Glavni proces se koristi."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Usluga <xliff:g id="COMP_NAME">%1$s</xliff:g> se koristi."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Pružalac <xliff:g id="COMP_NAME">%1$s</xliff:g> se koristi."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Zaustaviti sistemsku uslugu?"</string>
    <string name="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">"Tastatura"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nemate odobrenje za promjenu jezika na uređaju."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Jezici i unos"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Alati"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatura i načini unosa"</string>
    <string name="system_language" msgid="1146762166579643257">"Jezici sistema"</string>
    <string name="phone_language" msgid="5986939176239963826">"Jezici"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatska zamjena"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Ispravi pogrešno napisane riječi"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Automatsko veliko slovo"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Piši prvu riječ u rečenici velikim početnim slovom."</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatska interpunkcija"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Postavke fizičke tastature"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Pritisnite tipku za razmak dva puta kako biste umetnuli \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Prikaži lozinke"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Kratko prikazivanje znakova dok pišete"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Ovaj alat za provjeru pravopisa u mogućnosti je da prikuplja sav tekst koji upišete, uključujući lične podatke kao što su lozinke i brojevi kreditnih kartica. Alat je omogućila aplikacija <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Da li želite koristiti ovaj alat za provjeru pravopisa?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Postavke"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jezik"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastature"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Tastatura na ekranu"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard tastatura"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Tastatura na ekranu je dostupna"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Upravljajte tastaturama na ekranu"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opcije"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Pristupačnost"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fizička tastatura"</string>
    <string name="show_ime" msgid="4334255501724746849">"Koristi tastaturu na ekranu"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Zadržava se na ekranu dok je fizička tastatura aktivna"</string>
    <string name="bounce_keys" msgid="7419450970351743904">"Zanemari slučajne pritiske tipki"</string>
    <string name="bounce_keys_summary" msgid="6922850403920596246">"Omogućite opciju Zanemari slučajne pritiske tipki za pristupačnost fizičke tastature"</string>
    <string name="slow_keys" msgid="2891452895499690837">"Sporo reagiranje tipki"</string>
    <string name="slow_keys_summary" msgid="6147992959180167575">"Omogućite sporo reagiranje tipki radi pristupačnosti fizičke tastature"</string>
    <string name="sticky_keys" msgid="7317317044898161747">"Ljepljive tipke"</string>
    <string name="sticky_keys_summary" msgid="8520909829540989765">"Omogućite Ljepljive tipke za pristupačnost fizičke tastature"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Prečice tastature"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Prikaz liste prečica"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatura i alati radnog profila"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Tastatura na ekranu za posao"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Zadano"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Dodirna površina"</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">"Dodir za klik"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Pokreti na dodirnoj podlozi"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Prilagodite pojedinačne pokrete navigacije na dodirnoj podlozi"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Klizanje unazad"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Sadržaj se pomjera nagore kada kližete nadolje"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Dodir dolje desno"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Dodirnite donji desni ugao dodirne podloge za više opcija"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Brzina pokazivača"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Naučite pokrete dodirne podloge"</string>
    <string name="keywords_touchpad" msgid="8159846254066666032">"dodirna tabla, tabla na dodir, miš, kursor, klizanje, prevlačenje, desni klik, klik, pokazivač"</string>
    <string name="keywords_trackpad_bottom_right_tap" msgid="1285062446073929305">"desni klik, dodir"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Idite na početni ekran"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Prevucite nagore s tri prsta bilo gdje na dodirnoj podlozi"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Nazad"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Prevucite slijeva ili zdesna s tri prsta"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Prikažite nedavne aplikacije"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Prevucite nagore s tri prsta, zadržite, a zatim pustite"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Prikažite obavještenja i Brze postavke"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Prevucite nadolje s tri prsta na početnom ekranu"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Prebacivanje između aplikacija"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Prevucite ulijevo ili udesno s četiri prsta"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Preskoči"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Naprijed"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Ponovo pokreni"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Gotovo"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Nazad"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Prevucite ulijevo ili udesno s tri prsta"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Odlazak na početni ekran"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Prevucite nagore s tri prsta"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Nedavne aplikacije"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Prevucite nagore s tri prsta, a zatim zadržite"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Obavještenja"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Prevucite nadolje s tri prsta"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Prebacivanje između aplikacija"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Prevucite ulijevo ili udesno s četiri prsta"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifikacijske tipke"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Promijenite ponašanje 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 želite vratiti sve modifikacijske tipke na zadano?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Gotovo"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Otkaži"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Poništi"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Odaberite modifikacijsku tipku"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Odaberite novu tipku 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">"Kontroler za igre"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Preusmjeravanje vibracije"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Pošalji vibraciju na kontroler za igre kada je povezan."</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Odaberite raspored tastature"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Postavi rasporede tastature"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Da biste izvršili prebacivanje, pritisnite kombinaciju tipki \"Control-Space\""</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Zadano"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Rasporedi tastature"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Rasporedi fizičke tastature"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Lični rječnik"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Lični rječnik za posao"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Dodajte riječi koje će se koristiti 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">"Dodajte u rječnik"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Više opcija"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Manje opcija"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Uredu"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Riječ:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Prečica:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Napišite riječ"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Neobavezna prečica"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Uredi riječ"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Uređivanje"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Nemate nijednu riječ u korisničkom rječniku. Da dodate riječ, dodirnite dugme Dodaj (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Za sve jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Više jezika…"</string>
    <string name="testing" msgid="6294172343766732037">"Testiranje"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Tastatura na ekranu, alati"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Tastatura na ekranu, fizička tastatura, alati"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fizička tastatura"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Raspored"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Odaberite gadžet"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Odaberi vidžet"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Kreirati vidžet i omogućiti pristup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Nakon što kreirate vidžet, aplikacija će moći pristupiti svemu prikazanom.\n\nAplikacija: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nVidžet: <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 da aplikacija <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> kreira vidžete i koristi njihove podatke"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Statistika korištenja"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Poredaj prema vrem. korištenja"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Pored. prema poslj. korištenja"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Poredaj prema imenu aplikacije"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Posljednja upotreba"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"nikada"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Vrijeme korištenja"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Pristupačnost"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Postavke pristupačnosti"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Prikaz, 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. Funkcije pristupačnosti se mogu kasnije promijeniti u Postavkama."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Promijenite veličinu fonta"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Čitač ekrana"</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će"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Prikaz"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Boja i pokret"</string>
    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
    <skip />
    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
    <skip />
    <!-- no translation found for color_contrast_note (7592686603372566198) -->
    <skip />
    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
    <skip />
    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
    <skip />
    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
    <skip />
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Zatamnjivanje ekrana"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrole za interakciju"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrole za vrijeme"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Kontrole sistema"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Preuzete aplikacije"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimentalno"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Oznake funkcija"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtriranje snoop zapisnika za Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Postavite filtere"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Omogućite i onemogućite Bluetooth da se promjene primijene"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP filtiranje snoop zapisnika za Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP filtriranje snoop zapisnika 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 se promjene primijene)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Da promijenite ovu opciju, postavite način rada Bluetooth HCI snoop zapisnika na Omogućeno filtrirano"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Čitač ekrana prvenstveno za slijepe i slabovidne osobe"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Dodirnite stavke na ekranu da se naglas pročitaju"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Postavke titlova"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"O postavkama titlova"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Saznajte više o postavkama titlova"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Uvećavanje"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Prečica za uvećavanje"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Uvećavanje pisanja"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Povećalo prati tekst dok pišete"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Uključeno pri promjeni aplikacije"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Povećalo ostaje uključeno i umanjuje prikaz pri promjeni aplikacije"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Džojstik"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktiviranje i pomicanje povećala pomoću džojstika na ekranu. Kontroliranje povećala dodirivanjem i zadržavanjem, a zatim prevlačenjem džojstika. Pomicanje samog džojstika dodirivanjem i prevlačenjem."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"O uvećavanju"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Saznajte više o uvećavanju"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Vrsta uvećavanja"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Uvećavanje prikaza preko cijelog ekrana, željenog područja ili prebacivanje s jedne opcije na drugu"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Cijeli ekran"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Djelimični prikaz ekrana"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Prebacivanje između cijelog i djelimičnog prikaza ekrana"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Odaberite način uvećavanja"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Uvećajte prikaz preko cijelog ekrana"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Uvećajte dio ekrana"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Prebacujte između cijelog i djelimičnog prikaza"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Dodirnite dugme prekidača da prebacujete između dvije opcije"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Prebaciti na dugme Pristupačnost?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Trostruki dodir za uvećavanje dijela ekrana prouzrokovat će kašnjenje unosa teksta i drugih radnji.\n\nDugme za pristupačnost pluta na vašem ekranu preko drugih aplikacija. Dodirnite ga da uvećate sadržaj."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Prebaci na dugme Pristupačnost"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Korištenje trostrukog dodira"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Ovo može usporiti tastaturu"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Kada koristite trostruki dodir da uvećate dio ekrana, možete primijetiti probleme u vezi s tastaturom.\n\nDa ih izbjegnete, možete promijeniti prečicu za uvećavanje 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">"Otkaži"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Postavke uvećavanja"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Uvećavanje pomoću prečice"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Uvećajte pomoću prečice i trostrukog dodira"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"O usluzi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_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">"Od: Billa"</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 kreirati nove balone?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Vrati postavke na zadano"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Postavke veličine prikaza i teksta su vraćene na zadano"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Vratiti veličinu prikaza i tekst na zadano?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Vrati na zadano"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Šta planiraš za vikend?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Idem na plažu. Želiš li sa mnom?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opcije"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Uvećajte prikaz na ekranu"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Dodirnite tri puta da zumirate"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Dodirnite dugme da zumirate"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Brzo uvećajte ekran da sadržaj postane veći"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Da uvećate:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Koristite prečicu da pokrenete uvećavanje.&lt;br/&gt; {1,number,integer}. Dodirnite ekran.&lt;br/&gt; {2,number,integer}. Prevlačite s 2 prsta da se krećete po ekranu.&lt;br/&gt; {3,number,integer}. Uhvatite s 2 prsta da podesite zumiranje.&lt;br/&gt; {4,number,integer}. Koristite prečicu da zaustavite uvećavanje.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Da uvećate privremeno:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Provjerite je li vrsta uvećavanja postavljena na prikaz preko cijelog ekrana.&lt;br/&gt; {1,number,integer}. Koristite prečicu da pokrenete uvećavanje.&lt;br/&gt; {2,number,integer}. Dodirnite i zadržite bilo gdje na ekranu.&lt;br/&gt; {3,number,integer}. Prevlačite prstom da se krećete po ekranu.&lt;br/&gt; {4,number,integer}. Podignite prst da zaustavite uvećavanje."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kada je uvećavanje uključeno, možete uvećavati sadržaj na ekranu.\n\n"<b>"Da zumirate"</b>", pokrenite uvećavanje, a zatim dodirnite ekran bilo gdje.\n"<ul><li>"Prevucite dva ili više prstiju za klizanje"</li>\n<li>"Uhvatite s dva ili više prstiju za podešavanje zumiranja"</li></ul>\n\n<b>"Za privremeno zumiranje"</b>" pokrenite uvećanje, a zatim dodirnite ekran bilo gdje i zadržite.\n"<ul><li>"Prevucite za kretanje po ekranu"</li>\n<li>"Podignite prst za umanjivanje"</li></ul>\n\n"Nije moguće uvećati na tastaturi ili traci za navigaciju."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Stranica <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Otvorite pomoću dugmeta za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Držite tipke za jačinu zvuka da otvorite"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Triput dodirnite ekran da otvorite"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Otvaranje dvostrukim dodirom ekrana s dva prsta"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Otvorite pokretom"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Korištenje pokreta za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Da koristite ovu funkciju, dodirnite dugme Pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> na dnu ekrana.\n\nDa prebacujete između funkcija, dodirnite i zadržite dugme Pristupačnost."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Da koristite ovu funkciju, dodirnite dugme za pristupačnost na ekranu."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Da koristite ovu funkciju, pritisnite i držite obje tipke za jačinu zvuka."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Da pokrenete i zaustavite uvećavanje, triput dodirnite bilo gdje na ekranu."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Da pokrenete i zaustavite uvećavanje, dvaput dodirnite bilo gdje na ekranu s dva prsta."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Da koristite ovu funkciju, prevucite s 2 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 2 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Da koristite ovu funkciju, prevucite s 3 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 3 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Da koristite funkciju pristupačnosti, prevucite s 2 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 2 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Da koristite funkciju pristupačnosti, prevucite s 3 prsta nagore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s 3 prsta nagore i zadržite."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Razumijem"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Postavke dugmeta"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Prečica za: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Pokret za pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Prevucite prema gore s 2 prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Prevucite prema gore s 3 prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Dodirnite dugme za pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Korištenje pokreta za pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Dodirnite dugme za pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> na dnu ekrana.\n\nDa prebacujete između funkcija, dodirnite i zadržite dugme za pristupačnost."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Prevucite s dva prsta prema gore s dna ekrana.\n\nDa prebacujete između funkcija, s dva prsta prevucite prema gore i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Prevucite s tri prsta prema gore s dna ekrana.\n\nDa prebacujete između funkcija, prevucite s tri prsta prema gore i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Više opcija"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"<xliff:g id="SERVICE">%1$s</xliff:g> – saznajte više"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Držite tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"držite tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Pritisnite i zadržite obje tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Dvostruki dodir ekrana s dva prsta"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"dvostruki dodir ekrana s dva prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Brzo dodirnite ekran {0,number,integer} put(a) s dva prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Dodirnite ekran triput"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"dodirnite ekran triput"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Brzo dodirnite ekran sljedeći broj puta: {0,number,integer}. Ova prečica 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">"Dugme Pirstupačnost podešeno je za aktiviranje usluge <xliff:g id="SERVICE">%1$s</xliff:g>. Da koristite uvećavanje, dodirnite i držite dugme Pristupačnost, zatim odaberite uvećavanje."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Pokret za pristupačnost je postavljen na <xliff:g id="SERVICE">%1$s</xliff:g>. Za korištenje uvećavanja prevucite s dva prsta prema gore s dna ekrana i zadržite. Nakon toga odaberite uvećavanje."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Prečica tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Postavke prečice"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Prečica sa zaključanog ekrana"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Dozvolite da se prečica funkcije uključi sa zaključanog ekrana. Držite obje tipke za jačinu zvuka nekoliko sekundi."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Dugme za pristupačnost"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Dugme i pokret za pristupačnost"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Brzo pristupajte funkcijama pristupačnosti s bilo kojeg ekrana"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"O dugmetu za pristupačnost"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"O dugmetu za pristupačnost i pokretu"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Saznajte više o dugmetu za pristupačnost i pokretu"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Korištenje dugmeta za pristupačnost. Pokret nije dostupan s navigiranjem pomoću 3 dugmeta."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Brzo pristupite funkcijama pristupačnosti"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Da započnete:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Idite u postavke pristupačnosti&lt;br/&gt; {1,number,integer}. Odaberite funkciju i dodirnite prečicu&lt;br/&gt; {2,number,integer}. Odaberite želite li koristiti dugme ili pokret da pristupite funkciji&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Da započnete:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Idite u postavke pristupačnosti&lt;br/&gt; {1,number,integer}. Odaberite funkciju i dodirnite prečicu&lt;br/&gt; {2,number,integer}. Odaberite dugme da pristupite funkciji&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Korištenje dugmeta 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 kada se ne koristi"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Blijedi nakon nekoliko sekundi da lakše možete vidjeti ekran"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Providno kada se ne koristi"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Providno"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nije providno"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst visokog kontrasta"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Promjena boje teksta u crnu ili bijelu. Maksimalno se povećava kontrast s pozadinom."</string>
    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
    <skip />
    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
    <skip />
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatsko ažurir. uvećav. ekrana"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ažurira uvećavanje ekrana kod prelaza aplikacija"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Dugme uklj./isklj. prekida poziv"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Veliki pokazivač miša"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Isticanje pokazivača miša da bude uočljiviji"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Zatamnjivanje svih aplikacija"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Odnosi se na apl. bez vlastite tamne teme. Neke apl. mogu imati problem s prikazom, kao obrtanje boja."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Ukloni animacije"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Smanjite kretanje na ekranu ekranu"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Mono zvuk"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kombiniranje kanala prilikom reprodukcije zvuka"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Balans zvuka"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Lijevo"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Desno"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Zadano"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekundi"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekundi"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuta"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minute"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Vrijeme za poduzimanje radnje za pristupačnost"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"O vremenu za poduzimanje radnje (istek vremena pristupačnosti)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Saznajte više o vremenu za poduzimanje radnje (istek vremena pristupačnosti)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Vrijeme za poduzimanje radnje"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Ovu postavku za vrijeme ne podržavaju sve aplikacije"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Odaberite koliko dugo želite da se prikazuju privremene poruke koje od vas zahtijevaju da preduzmete radnju"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Odgoda za dodirivanje i držanje"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inverzija boja"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Koristi inverziju boja"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Prečica za inverziju boja"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Inverzija boja mijenja svijetle ekrane u tamne, kao i tamne u svijetle."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Imajte na umu:&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Boje u medijskim sadržajima i slikama će se promijeniti.&lt;/li&gt; &lt;li&gt; Inverzija boja funkcionira u svim aplikacijama.&lt;/li&gt; &lt;li&gt; Za prikazivanje tamne pozadine može se koristiti tamna tema.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"ulazak u postavke"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatski klik (vrijeme zadržavanja)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Automatski klik (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 da povezani miš automatski klikne kada se kursor prestane pomicati određeno vrijeme"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automatski klik može biti koristan kada je klikanje mišom otežano"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automatski klik je isključen"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kratko"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekunde"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Srednje"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundi"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Dugo"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunda"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Prilagođeno"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kraće"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Duže"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Trajanje automatskog klika"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibracija i haptika"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Kontrola jačine vibracije za različite upotrebe"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Uključeno"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Isključeno"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Postavka je onemogućena jer je uređaj postavljen na nečujno"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Pozivi"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Obavještenja 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 pri alarmu"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibracija medijskog sadržaja"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Vibracija tastature"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibracija pri zvonu"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibracija pri obavještenjima"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Povratne informacije na dodir"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Koristi <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Otvaranje aplikacije <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Aplikacija <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> je dodana u Brze postavke. Prevucite nadolje da je uključite ili isključite bilo kada."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Aplikaciju <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> također možete dodati u Brze postavke s vrha ekrana"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Ispravka boja je dodana u Brze postavke. Prevucite nadolje da je uključite ili isključite bilo kada."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Ispravku boja također možete dodati u Brze postavke s vrha ekrana"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Inverzija boja je dodana u Brze postavke. Prevucite nadolje da je uključite ili isključite bilo kada."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Inverziju boja također možete dodati u Brze postavke s vrha ekrana"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Dodatno zatamnjenje je dodano u Brze postavke. Prevucite nadolje da ga uključite ili isključite bilo kada."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Dodatno zatamnjenje također možete dodati u Brze postavke s vrha ekrana"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Način rada jednom rukom je dodan u Brze postavke. Prevucite nadolje da ga uključite ili isključite bilo kada."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Način rada jednom rukom također možete dodati u Brze postavke s vrha ekrana"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Veličina fonta je dodana u Brze postavke. Prevucite nadolje da promijenite veličinu fonta u bilo kojem trenutku."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Odbacivanje"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Koristi ispravku boja"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Prečica za ispravku boja"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"O ispravci boja"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Saznajte više o ispravci 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žane aplikacije"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Veličina i stil titlova"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Veličina teksta <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Više opcija"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Prilagodite veličinu i stil titlova da ih lakše čitate"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Ove postavke titlova nisu podržane u svim medijskim aplikacijama"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Prevlačenje pomoću 2 prsta s dna ekrana prema gore"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Držite tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trostruki dodir ekrana"</string>
    <!-- no translation found for accessibility_shortcut_edit_screen_title (4494142067760961499) -->
    <skip />
    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
    <skip />
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Nastavi"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Slušni aparati"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"S telefonom možete koristiti slušne aparate, kohlearne implantate i druge uređaje za pojačavanje zvuka"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"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šne aparate"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Na sljedećem ekranu dodirnite slušne aparate. Možda ćete morati odvojeno upariti slušne aparate za lijevo i desno uho.\n\nProvjerite jesu li slušni aparati uključeni i spremni za uparivanje."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> aktivan"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, samo lijevi"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, samo desni"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, lijevi i desni"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> još 1"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Upari novi uređaj"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Slušni aparati"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Sačuvani uređaji"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Kontrole slušnog aparata"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Prečica za slušni aparat"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilnost sa slušnim aparatom"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Poboljšava kompatibilnost s telezavojnicama i smanjuje neželjeni šum"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Informacije o slušnim aparatima"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Uparite slušni aparat"</string>
    <!-- no translation found for accessibility_hearing_device_pairing_intro (7022201665808166517) -->
    <skip />
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupni slušni aparati"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Ne vidite slušni aparat?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Prikaži više uređaja"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Automatsko podešavanje"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Zvučni opis"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Slušajte opis dešavanja na ekranu za podržane filmove i serije"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"zvučni opis, zvuk, opis, slaba vidljivost"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Prečica je uključena"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Isključeno"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Uključeno"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Isključeno"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Ne radi. Dodirnite za informacije."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Ova usluga ne radi ispravno."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Prečice 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">"Slabo prepoznavanje zelene, deuteranomalija"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Slabo prepoznavanje crvene, protanomalija"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalija"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Dodatno zatamnjenje"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Dodatno zatamni ekran"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Prečica 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 ekran da vam bude ugodnije čitati"</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">"Ostavi uključeno 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} sekunda}one{{time} sekunda}few{{time} sekunde}other{{time} sekundi}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Postavke"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Uključeno"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Isključeno"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Pregled"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardne opcije"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Jezik"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Veličina teksta"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Stil titlova"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Prilagođene opcije"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Boja pozadine"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Prozirnost pozadine"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Boja prozora za titlove"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Prozirnost prozora naslova"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Boja teksta"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Prozirnost teksta"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Boja rubova"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Vrsta rubova"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Porodica fontova"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Titlovi će izgledati ovako"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Zadano"</string>
    <string name="color_title" msgid="2511586788643787427">"Boja"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Zadano"</string>
    <string name="color_none" msgid="3703632796520710651">"Nema boje"</string>
    <string name="color_white" msgid="1896703263492828323">"Bijela"</string>
    <string name="color_gray" msgid="8554077329905747877">"Siva"</string>
    <string name="color_black" msgid="9006830401670410387">"Crna"</string>
    <string name="color_red" msgid="5210756997426500693">"Crvena"</string>
    <string name="color_green" msgid="4400462091250882271">"Zelena"</string>
    <string name="color_blue" msgid="4997784644979140261">"Plava"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cijan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Žuta"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Dozvoliti da usluga <xliff:g id="SERVICE">%1$s</xliff:g> ima punu kontrolu nad vašim uređajem?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"Usluga <xliff:g id="SERVICE">%1$s</xliff:g> mora:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Aplikacija nije dala odobrenje za zahtjev pa postavke ne mogu potvrditi vaš odgovor."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"Usluga <xliff:g id="SERVICE">%1$s</xliff:g> zahtijeva potpunu kontrolu ovog uređaja. Usluga može čitati sadržaj ekrana i djelovati u ime korisnika s potrebama za pristupačnost. Ovaj nivo kontrole nije prikladan za većinu aplikacija."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Puna kontrola je prikladna za aplikacije koje vam pomažu kod potreba pristupačnosti, ali nije za većinu aplikacija."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Prikaz i kontrola ekrana"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Može čitati sav sadržaj na ekranu i prikazivati sadržaj preko drugih aplikacija."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Prikaz i izvršavanje radnji"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Može pratiti vaše interakcije s aplikacijom ili hardverskim senzorom te ostvariti interakciju s aplikacijama umjesto vas."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Dozvoli"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Odbij"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Isključi"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Ostavi uklj."</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Isključiti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nema instaliranih usluga"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nije odabrana usluga"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nije naveden opis."</string>
    <string name="settings_button" msgid="2195468788019730377">"Postavke"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"osjetljivost na svjetlost, fotofobija, tamna tema, migrena, glavobolja, način rada za čitanje, noćni način rada, smanjivanje osvjetljenja, bijela tačka"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"vid, sluh, slijepi, gluhi, motorika, pokretljivost ruku, pomoćni, pomoć, jednostavnost korištenja, jednostavnost pristupa, ruka, pomoć"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"povećalo prozora, zumiranje, uvećavanje, slabi vid, uvećanje, povećavanje"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"titlovi, titlovanje, cc, automatska transkripcija, poteškoće sa sluhom, gubitak sluha, transkripcija u stvarnom vremenu pomoću računara, 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 ekrana, veliki ekran"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Visoki kontrast, slabi vid, boldirani font, boldirani tekst"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"podešavanje boje"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"potamnjivanje ekrana, posvjetljivanje ekrana"</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="6811744211216280998">"motorika, miš, vanjski miš, naglavni miš, prilagodljivi miš, invalidska kolica, džojstik"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"slušni aparati, oštećenje sluha, gubitak sluha, kohlearni implantati, uređaji za pojačavanje zvuka, procesori zvuka, PSAP"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"poteškoće sa sluhom, gubitak sluha, titlovi, teletype, tty"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"tri dugmeta"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"pokretljivost ruku, motorika, starija osoba, artritis, RSI, moždani udar, tremor, multipla skleroza, cerebralna paraliza, drhtanje, povreda uzrokovana učestalim ponavljanjem radnje, ruka"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"odgoda, pokretljivost ruku, starija osoba"</string>
    <string name="print_settings" msgid="8519810615863882491">"Štampanje"</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 štampanja}one{Uključena je # usluga štampanja}few{Uključene su # usluge štampanja}other{Uključeno je # usluga štampanja}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 zadatak štampanja}one{# zadatak štampanja}few{# zadatka štampanja}other{# zadataka štampanja}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Usluge štampanja"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nema instaliranih usluga"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nije pronađen nijedan štampač"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Postavke"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Dodaj pisače"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Uključeno"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Isključeno"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Dodajte uslugu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Dodaj štampač"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Pretražite"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Traženje štampača"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Usluga je onemogućena"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Zadaci štampanja"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Zadatak ispisivanja"</string>
    <string name="print_restart" msgid="4424096106141083945">"Ponovo pokreni"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Otkaži"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Konfiguriranje za <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Štampa se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Otkazuje se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Greška pisača <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Štampač je blokirao <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Okvir za pretraživanje je prikazan"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Okvir za pretraživanje je skriven"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Više informacija o ovom štampaču"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterija"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Šta je sve koristilo bateriju"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Preostalo <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do pune baterije"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Vrijeme korištenja uređaja"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Vrijeme u pozadini"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Baterija je slaba"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Dopustite aplikaciji da radi u pozadini"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Ograničiti aktivnost u pozadini?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ako aplikaciji ograničite aktivnost u pozadini, može raditi nepravilno"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Aplikaciju ne možete ograničiti jer nije postavljena optimizacija baterije.\n\nDa je ograničite prvo uključite optimizaciju."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Upravljajte potrošnjom baterije"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Omogućite korištenje u pozadini"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Omogućite za ažuriranja u stvarnom vremenu. Onemogućite radi uštede baterije"</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">"Dozvolite potrošnju baterije u pozadini bez ograničenja. Moguća je veća potrošnja baterije."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimizirajte na osnovu potrošnje. Preporučeno je za većinu aplikacija."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Ograničite potrošnju baterije u pozadini. Aplikacija možda neće funkcionirati kako je očekivano. Obavještenja mogu kasniti."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Ako promijenite način na koji aplikacija koristi bateriju, to može uticati na njene performanse."</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">"Korištenje ekrana od potpune napunjenosti"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Potrošnja baterije"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalji historije"</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">"Prikaz potrošnje od posljednjeg potpunog punjenja"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Potrošnja baterije za aplikaciju"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detalji o upotrebi"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Podesite potrošnju energije"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Uključeni paketi"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikacije rade uobičajeno"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Nivo napunjenosti baterije je nizak"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Uključite uštedu baterije da produžite vijek trajanja baterije"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Poboljšajte vijek trajanja baterije"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Uključite Upravitelja baterije"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Uključite Uštedu baterije"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Baterija bi vam se mogla isprazniti brže nego obično"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Ušteda baterije je uključena"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Više informacija o Uštedi baterije"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Neke funkcije mogu biti ograničene"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Veća potrošnja baterije"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Pogledajte aplikacije s najvećom potrošnjom"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Punjenje je optimizirano radi zaštite baterije"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Radi produženja vijeka trajanja baterije, punjenje je optimizirano"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Saznajte više o pauziranju punjenja"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Nastavi punjenje"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Uključuje aktivnost u pozadini s velikom potrošnjom baterije"</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{Aplikacija {label} je nedavno ograničena}one{# aplikacija je nedavno ograničena}few{# aplikacija su nedavno ograničene}other{# aplikacija je nedavno ograničeno}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{Aplikacija {label} ima visoku potrošnju baterije u pozadini}one{# aplikacija ima visoku potrošnju baterije u pozadini}few{# aplikacije imaju visoku potrošnju baterije u pozadini}other{# aplikacija ima visoku potrošnju baterije u pozadini}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Ova aplikacija ne može raditi u pozadini}one{Ove aplikacije ne mogu raditi u pozadini}few{Ove aplikacije ne mogu raditi u pozadini}other{Ove aplikacije ne mogu raditi u pozadini}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Ograničiti aplikaciju?}one{Ograničiti # aplikaciju?}few{Ograničiti # aplikacije?}other{Ograničiti # aplikacija?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Da uštedite bateriju, spriječite aplikaciju <xliff:g id="APP">%1$s</xliff:g> da koristi bateriju u pozadini. Moguće je da ta aplikacija neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Da uštedite bateriju, spriječite ove aplikacije da koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Da uštedite bateriju, spriječite ove aplikacije da koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti.\n\nAplikacije:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Ograniči"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Ukloniti ograničenje?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Ova aplikacija će moći koristiti bateriju u pozadini. Vaša baterija bi se mogla isprazniti prije nego što očekujete."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Ukloni"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Otkaži"</string>
    <string name="battery_tip_charge_to_full_button" msgid="9172893341338732733">"Zaobiđi"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="1567827436103364999">"Provjerite opremu za punjenje"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Saznajte više o nekompatibilnom punjenju"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Upravitelj baterije"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Automatsko upravljanje aplikacijama"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kada Upravitelj baterije otkrije da aplikacije troše bateriju, imat ćete opciju da na te aplikacije postavite ograničenje. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Ograničene aplikacije"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Ograničenje potrošnje baterije na # aplikaciju}one{Ograničenje potrošnje baterije na # aplikaciju}few{Ograničenje potrošnje baterije na # aplikacije}other{Ograničenje potrošnje baterije na # 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">"Ovim aplikacijama je ograničena potrošnja baterije u pozadini. Moguće je da neće raditi kao što je očekivano i da će obavještenja kasniti."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Upotreba Upravitelja baterije"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Otkrij kada aplikacije troše bateriju"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Otkrivanje kada aplikacije brzo troše bateriju"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Otkrivanje kada aplikacije brzo troše bateriju"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# aplikacija je ograničena}one{# aplikacija je ograničena}few{# aplikacije su ograničene}other{# aplikacija je 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">"Došlo je do problema prilikom očitavanja mjerača stanja baterije."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Dodirnite da saznate više o ovoj grešci"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekran"</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">"WiFi"</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">"Korištenje ekrana <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"Aplikacija <xliff:g id="APP">%2$s</xliff:g> koristi <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> ukupne baterije"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Pregled od posljednje potpune napunjenosti"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Posljednja potpuna napunjenost"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Potpuna napunjenost traje"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Preostali vijek trajanja baterije je približan i može se mijenjati u zavisnosti od korištenja"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Potrošnja baterije"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Nema potrošnje od posljednjeg potpunog punjenja"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Nema korištenja za posljednja 24 h"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"od posljednjeg potpunog punjenja"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Sistemske aplikacije"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Deinstalirane aplikacije"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Ostalo"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Procjena preostalog vremena"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Do potpune napunjenosti"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Procjena se može mijenjati u zavisnosti od korištenja"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Server za medijske sadržaje"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimizacija aplikacija"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Dijeljenje internetske veze"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Uklonjene aplikacije"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Ušteda baterije"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Automatski uključi"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Nema rasporeda"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Na osnovu vaše rutine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Uključit će se na osnovu vaše rutine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Na osnovu postotka"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Ušteda baterije će se uključiti ako je vjerovatno da će se baterija istrošiti prije sljedećeg uobičajenog punjenja"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Uključit će se na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Postavite raspored"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Produžite vijek trajanja baterije"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Isključi nakon punjenja"</string>
    <string name="battery_saver_sticky_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">"Ušteda baterije se isključuje kada baterija 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 Uštedu baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Automatsko uključivanje"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikad"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"na <xliff:g id="PERCENT">%1$s</xliff:g> baterije"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Postotak napunjenosti baterije"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Prikaz postotka napunjenosti baterije na statusnoj traci"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Nivo baterije od posljednjeg potpunog punjenja"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Nivo napunjenosti baterije u posljednja 24 h"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Korištenje aplikacija od posljednjeg potpunog punjenja"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Korištenje aplikacije u posljednja 24 h"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Korištenje sistema od posljednjeg potpunog punjenja"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Korištenje sistema u posljednja 24 h"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Korištenje sistema za: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Korištenje aplikacije za: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Korištenje sistema od posljednjeg potpunog punjenja do <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Korištenje aplikacija od posljednjeg potpunog punjenja do <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <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">"Pozadina: manje od minute"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Vrijeme korištenja uređaja: manje od jedne minute"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Manje od jedne 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">"Pozadina: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Vrijeme korištenja uređaja: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Podaci o potrošnji baterije će biti dostupni za nekoliko sati nakon što se potpuno napuni"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"sada"</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_time_info_and_battery_level" msgid="6732629268310936155">"<xliff:g id="TIME_INFO">%1$s</xliff:g> <xliff:g id="BATTERY_LEVEL">%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 satu"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Postotak napunjenosti baterije od <xliff:g id="START_PERCENTAGE">%1$s</xliff:g> do <xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Potrošnja baterije od posljednjeg potpunog punjenja"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Potrošnja baterije za period <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Vrijeme korištenje uređaja od posljednjeg potpunog punjenja"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Vrijeme korištenja uređaja za period <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Pregled prema aplikacijama"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Pregled prema sistemima"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Zbog pregleda kvaliteta prije isporuke broj ciklusa možda neće biti nula prilikom prvog korištenja"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistika procesa"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Geeky statistike o pokrenutim procesima"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Iskorištena memorija"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> od <xliff:g id="TOTALRAM">%2$s</xliff:g> korišteno tokom zadnjih <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> RAM-a korišteno tokom <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Pozadina"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Prvi plan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Keširano"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Izvorni"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Keš-memorije"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Upotreba RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Korištenje RAM-a (u pozadini)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Vrijeme izvršavanja"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesi"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Usluge"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Trajanje"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detalji o memoriji"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 sata"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 sati"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 sati"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 dan"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Prikaži sistemske procese"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Sakrij sistemske procese"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Prikaži postotke"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Koristi Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Tip statističkih podataka"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Pozadina"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Prvi plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Keširano"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Glasovni unos i izlaz"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Postavke glasovnog unosa i izlaza"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Glasovno pretraživanje"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android tastatura"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Podešavanja 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">"Cela aktuelna reč i interakcija"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Jednostavno pretvaranje govora u tekst"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Ova usluga za glasovni unos će biti u mogućnosti da obavlja uvijek uključeno praćenje glasa i da u vaše ime kontrolira aplikacije omogućene glasom. Ona dolazi iz <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g> aplikacija. Omogućiti korištenje ove usluge?"</string>
    <string name="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 programa"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Brzina govora i visina glasa"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Program"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Jezik govora"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalirajte Glasove"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Nastavite na aplikaciju <xliff:g id="TTS_APP_NAME">%s</xliff:g> da instalirate glasove"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Otvori aplikaciju"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Otkaži"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Vrati na zadano"</string>
    <string name="tts_play" msgid="2945513377250757221">"Pokreni"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="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">"Prilagodljiva povezivost"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Produžava vijek trajanja baterije i poboljšava performanse uređaja automatskim upravljanjem vašim mrežnim vezama"</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">"Koristi prilagodljivo povezivanje"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Pohrana akreditiva"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instaliranje certifikata"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Brisanje akreditiva"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Uklanjanje svih certifikata"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Pouzdani akreditivi"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Prikaz pouzdanih CA certifikata"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Korisnički akreditivi"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Prikaz i izmjena pohranjenih akreditiva"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Napredno"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Akreditivi nisu dostupni za ovog korisnika"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instalirani za VPN i aplikacije"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Instalirano za WiFi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Instalirano za WiFi (u upotrebi)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Ukloniti sav sadržaj?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Pohrana akreditiva je izbrisana."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Nije uspjelo bris. memorije vjerodaj."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apl. s pristupom pod. o korišt."</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA certifikat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Korisnički cert. za VPN i apl."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certifikat za WiFi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Vaši podaci neće biti privatni"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Web lokacije, aplikacije i VPN-ovi koriste CA certifikate za šifriranje. Instalirajte CA certifikate samo ako dolaze od organizacija kojima vjerujete. \n\nAko instalirate CA certifikat, vlasnik certifikata može pristupiti vašim podacima, kao što su lozinke ili detalji o kreditnoj kartici, s web lokacija koje posjećujete ili iz aplikacija koje koristite, čak i ako su ti podaci šifrirani."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Nemoj instalirati"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Ipak instaliraj"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certifikat nije instaliran"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Dozvoliti aplikaciji "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" da instalira certifikate na ovaj uređaj?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Ti certifikati će potvrditi vaš identitet dijeljenjem jedinstvenog ID-a vašeg uređaja s aplikacijama i URL-ovima u nastavku"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nemoj dozvoliti"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Dozvoli"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Prikaži više"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Apl. za upravljanje certifik."</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Nema"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Certifikati će potvrditi vaš identitet prilikom korištenja aplikacija i URL-ova 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 ovu aplikaciju?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Ova aplikacija neće upravljati certifikatima, ali će ostati na vašem uređaju. Svi certifikati koje je aplikacija instalirala će se deinstalirati."</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">"Postavi ponašanje prilikom upućivanja hitnog poziva"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Izrada sigurnosne kopije"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Sigurnosna kopija i vraćanje"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Lični podaci"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Izrada sigurnosne kopije podataka"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Pravite sigurnosne kopije podataka aplikacija, lozinki za WiFi te drugih postavki na Google serverima"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Račun za sigurnosne kopije"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Upravljajte računom za sigurnosne kopije"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Uvrstite podatke aplikacije"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatsko vraćanje"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Prilikom ponovnog instaliranja aplikacije, vraća sigurnosne kopije postavki i podataka"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Usluga za izradu sigurnosne kopije nije aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Nijedan račun trenutno ne pravi sigurnosne kopije podataka"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Želite li prestati sa izradom sigurnosnih kopija lozinki za WiFi, oznaka, drugih postavki te podataka aplikacija i izbrisati sve kopije sa Google servera?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Prestani da praviš sigurnosne kopije podataka (npr. lozinke za WiFi i istorija poziva) i podataka aplikacije (npr. postavke i fajlovi koje pohranjuju aplikacije), i izbriši sve kopije na udaljenim serverima?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Daljinski pokrenite automatsku izradu sigurnosnih kopija podataka na uređaju (npr. WiFi lozinki i historije poziva) i podataka iz aplikacija (npr. postavki i fajlova koje pohranjuju aplikacije).\n\nKada uključite automatsku izradu sigurnosnih kopija, podaci iz uređaja i aplikacija se periodično pohranjuju daljinski. Podaci iz aplikacije mogu biti bilo koji podaci koje je aplikacija sačuvala (na osnovu programerskih postavki), uključujući i potencijalno osjetljive podatke, kao što su kontakti, poruke i fotografije."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Postavke administratora uređaja"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplikacija administratora uređaja"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktiviraj ovu aplikaciju administratora uređaja"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Deinstaliraj aplikaciju"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktiviraj i deinstaliraj"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplikacije administratora uređaja"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nema dostupnih aplikacija administratora uređaja"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nema dostupnih pouzdanih agenata"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivirati aplikaciju administratora uređaja?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiviraj aplikaciju administratora uređaja"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrator uređaja"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Ako aktivirate ovu aplikaciju administratora, omogućit ćete aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvršava sljedeće operacije:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> će pratiti ovaj uređaj i upravljati njime."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Ova aplikacija administratora je aktivna i omogućava aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvršava sljedeće operacije:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Aktivirati Upravitelj profila?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Dozvoliti nadzor?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ako nastavite, vašim korisnikom će upravljati vaš administrator koji će, osim vaših ličnih podataka, moći pohranjivati i povezane podatke.\n\nVaš administrator može pratiti i upravljati postavkama, pristupom, aplikacijama i podacima koji su povezani s ovim korisnikom, uključujući aktivnost na mreži i informacije o lokaciji vašeg uređaja."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Administrator je onemogućio ostale opcije"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Saznajte više"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Zapisnik obavještenja"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historija obavještenja"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"U posljednjem periodu od %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{# obavještenje}one{# obavještenje}few{# obavještenja}other{# obavještenja}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Melodija zvona telefona i vibracija"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detalji o mreži"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinhronizacija omogućena"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinhronizacija onemogućena"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sinhronizuje se"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Greška pri sinhroniziranju."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinhronizacija nije uspjela"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinhronizacija aktivna"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinhroniziraj"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Trenutno ima problema sa sinhroniziranjem. Ubrzo će opet raditi."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Dodajte račun"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Radni profil još uvijek nije dostupan"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Poslovne aplikacije"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Uklonite radni profil"</string>
    <string name="background_data" msgid="321903213000101158">"Podaci u pozadini"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikacije mogu sinhronizirati, slati i primati podatke u bilo koje vrijeme"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Onemogućiti podatke u pozadini?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Onemogućavanjem prijenosa podataka u pozadini produžava se trajanje baterije i smanjuje korištenje podataka. Neke aplikacije mogu i dalje koristiti vezu za prijenos podataka u pozadini."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinhronizacija UKLJUČENA"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinhronizacija ISKLJUČENA"</string>
    <string name="sync_error" msgid="846923369794727644">"Greška u sinhroniziranju"</string>
    <string name="last_synced" msgid="1527008461298110443">"Posljednja sinhronizacija: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sinhroniziraj sada…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Napravi rezervnu kopiju postavki"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Napravi rezervnu kopiju mojih postavki"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinhroniziraj sada"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Otkaži sinhroniziranje"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Dodirnite da sinhronizirate odmah<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalendar"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakti"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Postavke sinhroniziranja aplikacija"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Podaci i sinhroniziranje"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Promijeni lozinku"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Postavke računa"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Ukloni račun"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Dodajte račun"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Ukloniti račun?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Vaš administrator ne dopušta ovu promjenu"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nije moguće ručno sinhronizovati"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Sinhornizacija za ovu stavku trenutno nije moguća. Da biste promijenili ovu postavku, privremeno uključite podatke u pozadini i automatsko sinhroniziranje."</string>
    <string name="delete" msgid="8330605554706263775">"Izbriši"</string>
    <string name="select_all" msgid="7898929601615536401">"Označi sve"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Prijenos podataka"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Prijenos podataka na mobilnoj mreži i WiFi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Automatska sinhronizacija ličnih podataka"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Automatska sinhronizacija podataka za posao"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Automatski sinhroniziraj privatne podatke"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Promijeni ciklus…"</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dan u mjesecu za poništavanje ciklusa prijenosa podataka:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Nijedna apl. nije koristila pod. u ovom periodu."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Prvi plan"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Pozadina"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"ograničeno"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Isključiti prijenos podataka na mobilnoj mreži?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Ograniči mobilne podatke"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Postavi ograničenje za 4G podatke"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Ograničenje 2G-3G podataka"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Ograniči WiFi podatke"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"WiFi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilni"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobilne"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Ništa"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilni podaci"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G-3G podaci"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G podaci"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Prvi plan:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Pozadina:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Postavke aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Pozadinski podaci"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Omogućite prijenos podataka na mobilnoj mreži u pozadini"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Za ograničenje pozad. podataka ove aplikacije prvo postavite ogranič. mob. podataka."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Ograničiti podatke u pozadini?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Ova funkcija može uzrokovati da aplikacija koja ovisi o pozadinskim podacima prestane raditi kada su dostupne samo mobilne mreže.\n\nPrikladnije kontrole za prijenos podataka možete pronaći među postavkama koje su dostupne unutar aplikacije."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Ograničavanje prijenosa pozadinskih podataka moguće je samo ako ste postavili ograničenje za prijenos podataka na mobilnoj mreži."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Uključiti autom. sinhr. podataka?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Isključiti autom. sinhr. podataka?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Ovim će se uštedjeti na prijenosu podataka i potrošnji baterije, ali ćete morati ručno sinhronizirati svaki račun da prikupite najnovije informacije. Također, nećete primati obavještenja kada se izvrše ažuriranja."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Datum poništavanja ciklusa potrošnje"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Datum svakog mjeseca:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Postavi"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Postavite upozorenje o prijenosu podataka"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Postavite ograničenje prijenosa podataka"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Ograničavanje prijenosa podataka"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"upozorenje"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"ograničenje"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Uklonjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Uklonjene aplikacije i korisnici"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Korištenje mreže"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"S naplatom"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Naziv"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Vrsta"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa servera"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Unaprijed dijeljeni IPSec ključ"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec korisnički certifikat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec CA certifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec certifikat servera"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Prikaži napredne opcije"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Korisničko ime"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Lozinka"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Sačuvajte informacije o računu"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ne koristi se)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ne potvrđuj server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(primljeno od servera)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Unesena informacija ne podržava uvijek aktivni VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Otkaži"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Odbaci"</string>
    <string name="vpn_save" msgid="683868204634860888">"Sačuvaj"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Poveži se"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Zamijeni"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Uredite VPN profil"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Zaboravi"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Poveži se na <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Želite li prekinuti vezu s ovim VPN-om?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Prekini vezu"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Verzija"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Zaboravi VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Želite li zamijeniti postojeći VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Želite li postaviti uvijek uključen VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Kada se uključi ova postavka, nećete imati internetsku mrežu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Vaš postojeći VPN će se zamijeniti i nećete imati internetsku vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Već ste povezani na \"uvijek uključen\" VPN. Ako se povežete na drugu mrežu, vaša postojeća VPN će biti zamijenjena, a način rada \"uvijek uključeno\" će se isključiti."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Već ste povezani na VPN. Ako se povežete na drugu, postojeći VPN će biti zamijenjen."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Uključi"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> se ne može povezati"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Ova aplikacija ne podržava uvijek aktivni VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Dodaj VPN profil"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Uredi profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Izbriši profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Uvijek aktivni VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nije dodan nijedan VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Ostanite stalno povezani na VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Ova aplikacija ne podržava ovu funkciju"</string>
    <string name="vpn_always_on_summary_active" msgid="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">"Treba li zahtijevati VPN vezu?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nije sigurno. Ažurirajte na IKEv2 VPN"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Pokretanje nepodržanog VPN-a nije uspjelo."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Odaberite VPN profil s kojim će uvijek biti uspostavljena veza. Mrežni saobraćaj će biti dopušten samo kad je uspostavljena veza s tim VPN-om."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Ništa"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Uvijek aktivni VPN zahtijeva IP adresu i za server i za DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nema mrežne veze. Pokušajte ponovo kasnije."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Isključeni ste iz VPN-a"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Ništa"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Nedostaje certifikat. Pokušajte urediti profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Korisnik"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Onemogući"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Omogući"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Deinstaliraj"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Povjerenje"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Omogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Onemogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Trajno ukloniti korisnički CA certifikat?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Koristi mreža"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Unos sadržava"</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">"Detalji o akreditivima"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Uklonjeni akreditiv: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nije instaliran nijedan korisnički akreditiv"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Provjera pravopisa"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Provjera pravopisa za posao"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Ovdje unesite trenutnu lozinku za sigurnosnu kopiju čitavog sistema"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Ovdje unesite novu lozinku za sigurnosne kopije čitavog sistema"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Ovdje ponovo unesite novu lozinku za sigurnosnu kopiju čitavog sistema"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Postavi lozinku za sigurnosnu kopiju"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Otkaži"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Dodatna ažuriranja sistema"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Mreža može biti nadzirana"</string>
    <string name="done_button" msgid="6269449526248267">"Gotovo"</string>
    <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} je instalirala CA certifikat na vaš uređaj, koji joj može omogućiti da prati aktivnosti na mreži uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovom certifikatu potražite od administratora.}one{Domena {orgName} je instalirala CA certifikate na vaš uređaj, koji joj mogu omogućiti da prati aktivnosti na mreži uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovim certifikatima potražite od administratora.}few{Domena {orgName} je instalirala CA certifikate na vaš uređaj, koji joj mogu omogućiti da prati aktivnosti na mreži uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovim certifikatima potražite od administratora.}other{Domena {orgName} je instalirala CA certifikate na vaš uređaj, koji joj mogu omogućiti da prati aktivnosti na mreži uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovim certifikatima potražite od administratora.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{Domena {orgName} je instalirala CA certifikat za vaš radni profil, koji joj može omogućiti da prati aktivnosti na poslovnoj mreži, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovom certifikatu potražite od administratora.}one{Domena {orgName} je instalirala CA certifikate za vaš radni profil, koji joj mogu omogućiti da prati aktivnosti na poslovnoj mreži, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovim certifikatima potražite od administratora.}few{Domena {orgName} je instalirala CA certifikate za vaš radni profil, koji joj mogu omogućiti da prati aktivnosti na poslovnoj mreži, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovim certifikatima potražite od administratora.}other{Domena {orgName} je instalirala CA certifikate za vaš radni profil, koji joj mogu omogućiti da prati aktivnosti na poslovnoj mreži, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nViše informacija o ovim certifikatima potražite od administratora.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Treća strana je u stanju da prati vaše mrežne aktivnosti, uključujući e-poruke, aplikacije i sigurne web lokacije. \n\nPouzdani akreditiv instaliran na vašem uređaju to omogućava."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Provjerite certifikat}one{Provjerite certifikate}few{Provjerite certifikate}other{Provjerite 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">"Dodaj korisnika ili profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Ograničeni profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nije postavljeno"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Nije postavljen – Ograničeni profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nije postavljen – Radni profil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Ne možete dodati više korisnika. Uklonite korisnika da dodate novog."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Ograničeni profili ne mogu dodati račune"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Izbrišite <xliff:g id="USER_NAME">%1$s</xliff:g> sa uređaja"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Postavke zaključavanja ekrana"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Dodavanje korisnika sa zaključanog ekrana"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Prebaci na administratora kada je uređaj priključen"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Želite li izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Izbrisati ovog korisnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Ukloniti ovaj profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Ukloniti radni profil?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Sve aplikacije i podaci s ovog profila će se izbrisati ako nastavite."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Dodavanje novog korisnika…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Izbriši korisnika"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Izbriši"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Sve aplikacije i podaci iz ove sesije će se izbrisati."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Ukloniti"</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 gosta"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Brisanje svih aplikacija i podataka gosta pri izlasku iz načina rada za gosta"</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 sesije gosta će se izbrisati sada, a sve buduće aktivnosti gosta će se izbrisati svaki put kada napustite način rada za gosta"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"izbrisati, gost, aktivnost, ukloniti, podaci, posjetilac, brisanje"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Dozvoli gostima da upućuju tel. pozive"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Historija poziva će se dijeliti s gostom"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Uključi telefonske pozive i SMS-ove"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Postavi korisnika kao administratora"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Izbriši korisnika"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Uključiti telefonske pozive i SMS-ove?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Historija poziva i SMS-ova će se dijeliti s ovim korisnikom."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Ukloniti administratorska prava?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Ako uklonite administratorska prava za ovog korisnika, vi ili drugi administrator ih možete vratiti kasnije."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informacije za hitne slučajeve"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informacije i kontakti za korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Otvorit aplikaciju <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Odobrenja za aplikaciju i sadržaj"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikacije s ograničenjima"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Proširi postavke za aplikaciju"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Odaberite aplikacije koje želite instalirati"</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">"Da platite pomoću aplikacije za plaćanje, prislonite poleđinu uređaja 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">"Zadano plaćati poslovnom aplikacijom?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Da platite pomoću poslovne aplikacije:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"radni profil mora biti uključen."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"morate unijeti poslovni PIN, uzorak ili lozinku ako je 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">"Zadana aplikacija za plaćanje"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nije postavljeno"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Koristite zadanu aplikaciju za plaćanje"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Koristite zadanu aplikaciju 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 terminalu za beskontaktno plaćanje, platite koristeći:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Plaćanje na terminalu"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Postavite aplikaciju za plaćanje, zatim jednostavno prislonite poleđinu svog telefona uz bilo koji terminal označen simbolom beskontaktnog povezivanja."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Razumijem"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Više…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Postavite zadanu aplikaciju za plaćanje"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Ažurirajte zadanu aplikaciju za plaćanje"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Na terminalu za beskontaktno plaćanje, platite koristeći aplikaciju <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Na terminalu za beskontaktno plaćanje, platite koristeći aplikaciju <xliff:g id="APP_0">%1$s</xliff:g>.\n\nTime se zamjenjuje aplikacija <xliff:g id="APP_1">%2$s</xliff:g> kao zadana aplikacija za plaćanje."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Postavi zadano"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Ažuriraj"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Posao"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Ograničenja"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Ukloni ograničenja"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Promijeni PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Pomoć i pov. inform."</string>
    <string name="user_account_title" msgid="6389636876210834864">"Račun za sadržaj"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID fotografije"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Ekstremne prijetnje"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Primite upozorenja o ekstremnim prijetnjama po život i imovinu"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ozbiljne prijetnje"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Primi upozorenja o ozbiljnim prijetnjama po život i imovinu"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER upozorenja"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Prijem objava o otmicama djece"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Ponovi"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Hitna upozorenja putem bežične mreže"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Mrežni operateri"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Nazivi pristupnih tačaka"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Napredno pozivanje"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Pozivanje putem 4G mreže"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Koristite LTE usluge da poboljšate glasovne pozive (preporučeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Koristite 4G usluge da poboljšate glasovne pozive (preporučeno)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Koristite 5G za glasovne pozive"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Pošalji kontakte mobilnom operateru"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Pošaljite brojeve telefona svojih kontakata da omogućite poboljšane funkcije"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Poslati kontakte mobilnom operateru <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Poslati kontakte vašem mobilnom operateru?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Brojevi telefona vaših kontakata periodično će se slati mobilnom operateru <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

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

</xliff:g>Pomoću ovih informacija utvrđuje se da li vaši kontakti mogu koristiti određene funkcije, kao što su video pozivi ili neke funkcije za razmjenu poruka."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Preferirana vrsta mreže"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (preporučeno)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS poruke"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Slanje i primanje podataka kada je prijenos podataka na mobilnoj mreži isključen"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Automatski promijeni prijenos podataka na mobilnoj mreži"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Koristite ovu mrežu kada ima bolju dostupnost"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM za Work"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Aplikacija i pristup sadržaju"</string>
    <string name="user_rename" msgid="8735940847878484249">"PROMIJENI NAZIV"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Postavi ograničenja za aplikacije"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontroliše <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Ova aplikacija može pristupiti vašim računima"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Ova aplikacija može pristupati vašim računima. Kontrolu vrši <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"WiFi i mobilne mreže"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Dozvoli izmjenu postavki za WiFi i mobilne mreže"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Dozvoli izmjenu Bluetooth uparivanja i postavki"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Omogućava da aplikacije koriste informacije o lokaciji"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Nazad"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Naprijed"</string>
    <string name="wizard_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">"Prijenos podataka na mobilnoj mreži je nedostupan"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Dodirnite za odabir SIM-a za prijenos podataka"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Uvijek koristi ovo za pozive"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Odaberite SIM za prijenos podataka"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Odaberite SIM za SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Prebacivanje SIM-a za prijenos podataka. Ovo može potrajati do 1 min…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Koristiti operatera <xliff:g id="NEW_SIM">%1$s</xliff:g> za prijenos podataka?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Ako se prebacite na operatera <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> se više neće koristiti za prijenos podataka na mobilnoj mreži."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Koristi operatera <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Poziv putem"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Unesite ime SIM-a"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM slot %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Narandž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="6839556577405929262">"SIM je promijenjen"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Dodirnite za postavke"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Pitaj svaki put"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Potreban odabir"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Odabir SIM-a"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Postavke"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Mreža i internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobilna mreža, WiFi, pristupna tačka"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"WiFi, pristupna tač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 rada za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, način rada za vožnju"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, način rada za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, način rada za vožnju"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nije dostupno jer je NFC isključen"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Da koristite, najprije instalirajte aplikaciju za plaćanje"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedavne aplikacije, zadane aplikacije"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Pristup obavještenjima nije dostupan za aplikacije u novom radnom profilu."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Lozinke i računi"</string>
    <string name="account_dashboard_default_summary" msgid="7976899924144356939">"Prijedlozi za prijavu i automatsko popunjavanje"</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">"Kreirajte drugu instancu aplikacije tako da možete istovremeno koristiti dva računa."</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">"Brisanje svih klonova aplikacije"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Brisanje klonova aplikacije nije uspjelo"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Kreiranje…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Klonirano"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Kreiranje klona aplikacije <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Kreiran je klon aplikacije <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="2650807397396180351">"Jezici sistema, jezici aplikacija, regionalne postavke, govor"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, veza s mrežom, internet, bežično, podaci, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"WiFi obavještenje, wifi obavještenje"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"prijenos podataka"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Koristi 24-satni format"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Otvori koristeći"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikacije"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"vremenska zona"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Skočni prozor za chat, sistem, obavještenje, prozor, dijaloški okvir, ekran, prikazivanje preko drugih aplikacija, crtanje"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Svjetiljka, svjetlo, lampa"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, aktivacija/deaktivacija, kontrola"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilni, mobilni operater, bežični, podaci, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, pozovi, pozivanje"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekran, osjetljiv na dodir"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"zatamnjeni ekran, osjetljiv na dodir, baterija, svijetlo"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"zatamnjeni ekran, noć, boja, noćna smjena, osvjetljenje, boja ekrana, boja"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"pozadina, personalizirati, prilagoditi ekran"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"veličina teksta"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projiciranje, emitiranje, preslikavanje ekrana, dijeljenje ekrana, preslikavanje, dijeli ekran, emitiranje ekrana"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"prostor, disk, čvrsti disk, upotreba uređaja"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"potrošnja energije, punjenje"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"prikaz potrošnje baterije, potrošnja baterije, potrošnja energije"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"ušteda baterije, štednja baterije, ušteda"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"prilagodljive postavke, prilagodljiva baterija"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pravopis, rječnik, provjera pravopisa, automatsko ispravljanje"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"prepoznavač, ulaz, govor, govoriti, jezik, rad bez dodira, prepoznavanje, uvredljivo, riječ, zvuk, istorija, bluetooth slušalice"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"stopa, jezik, zadano, govori, govoriti, tts, pristupačnost, čitač ekrana, slijepi"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"sat, vojni"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetirati, vratiti, fabričke postavke"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"uništiti, izbrisati, vratiti, obrisati, ukloniti, vratiti na fabričke postavke"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"štampač"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"zvuk sa zvučnika, zvučnik, jačina zvuka, isključenje zvuka, tišina, zvučni zapis, muzika, haptički, vibrator, vibriranje"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ne ne uznemiravaj, prekinuti, prekidanje, pauza"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"u blizini, lokacija, historija, izvještavanje, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"račun, dodavanje računa, radni profil, dodaj račun, ukloni, izbriši"</string>
    <string name="keywords_users" msgid="3497517660077620843">"ograničenje, ograničavanje, ograničen"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"korekcija teksta, ispravan, zvuk, vibrirati, auto, jezik, gest, predložiti, prijedlog, tema, uvredljivo, riječ, vrsta, emoji, međunarodna"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"ponovo podesi, željene postavke, zadano"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplikacije, preuzimanje, aplikacije, sistem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikacije, odobrenja, sigurnost"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikacije, zadane"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorirati optimizacije, doziranje, stanje mirovanja aplikacije"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"jarke, RGB, sRGB, boja, prirodno, standardo"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, rezolucija, 1080 p, 1440 p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"boja, temperatura, D65, D73, bijela, žuta, plava, topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"prevuci za otključavanje, lozinka, uzorak, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"kačenje ekrana"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"poslovni izazov, rad, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"radni profil, upravljani profil, ujediniti, ujedinjenje, rad, profil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"aktivno, u stanju mirovanja, nemoj zaključavati, ostavi otključano prilikom sklapanja, sklapanje, zatvaranje, sklopi, zatvori, ekran je isključen"</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">"sigurnosna kopija"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"lice, otključaj, autentifikacija, prijava"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"lice, otključavanje, autentifikacija, prijava, otisak prsta, biometrija"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl verzija, 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, roming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, vrsta mobilne mreže, roming, 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, roming, 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, roming, 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_battery_info" msgid="3319796850366687033">"informacije o bateriji, datum proizvodnje, broj ciklusa, prva upotreba"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nivo sigurnosne zakrpe za android, verzija nemoduliranog signala, osnovna verzija"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, svijetlo, tamno, način rada, osjetljivost na svjetlost, fotofobija, zatamniti, potamniti, tamni način rada, migrena"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tamna tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"greška"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambijentalni prikaz, Prikaz zaključavanja ekrana"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"obavještenja na zaključanom ekranu, obavještenja"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"lice"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"otisak prsta, dodati otisak prsta"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"lice, otisak prsta, dodavanje otiska prsta"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"Otključavanje pomoću sata, dodajte Otključavanje pomoću sata"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"zatamnjenje ekrana, ekran osjetljiv na dodir, baterija, pametna osvijetljenost, dinamička osvijetljenost, automatska osvijetljenost"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"pametno, zatamni ekran, stanje mirovanja, baterija, istek vremena, pažnja, prikaz, ekran, neaktivnost"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, pametno, automatsko rotiranje, automatska rotacija, rotiraj, obrni, rotacija, uspravno, vodoravno, orijentacija, vertikalno, horizontalno"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"nadograditi, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, raspored, obavještenja, blokirati, tišina, vibriranje, stanje mirovanja, rad, fokusiranje, zvuk, isključenje zvuka, dan, radni dan, vikend, radni dan uvečer, događaj"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"ekran, vrijeme zaključavanja, istek vremena, zaključani ekran"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memorija, keš memorija, podaci, izbrisati, obrisati, osloboditi, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"povezan, uređaj, slušalice, slušalice s mikrofonom, zvučnik, bežično, uparivanje, slušalice za umetanje u uho, muzika, medij"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"pozadina, tema, mreža, prilagođavanje, personaliziranje"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikona, naglašavanje, boja, početni ekran, zaključavanje ekrana, prečica, veličina sata"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"zadani, asistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"plaćanje, zadano"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"dolazno obavještenje"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"povezivanje putem usb uređaja, povezivanje putem bluetooth uređaja, wifi pristupna tačka"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"haptika, vibriranje, vibracija"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptika, vibriranje, ekran, osjetljivost"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"haptika, vibriranje, telefon, poziv, osjetljivost, zvono"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"haptika, vibriranje, telefon, poziv, zvono, postepeno"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"haptika, vibriranje, osjetljivost, obavještenje"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"haptika, vibriranje, osjetljivost, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"haptika, vibriranje, osjetljivost, medijski sadržaj"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"haptika, vibriranje, vibracija"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"ušteda baterije, ljepljivo, istrajnost, ušteda energije, baterija"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, raspored, ušteda baterije, ušteda energije, baterija, automatski, procenat"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, napredno pozivanje, 4g pozivanje"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, napredno pozivanje, pozivanje putem 5g mreže"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"dodavanje jezika, dodaj jezik"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"veličina teksta, velika slova, veliki font, veliki tekst, slabi vid, povećavanje teksta, povećalo fonta, povećavanje fonta"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"uvijek uključeni ambijentalni prikaz (always on ambient display, AOD)"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"NFC, oznaka, čitač"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"tastatura, haptika, vibriraj"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Jačina zvuka, vibracija, Ne ometaj"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Jačina zvuka medija"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Jačina zvuka emitiranja"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Jačina zvuka poziva"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Jačina zvuka alarma"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Jačina zvuka zvona i obavještenja"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Jačina zvuka zvona"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Jačina zvuka obavještenja"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Zvuk zvona je utišan"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Zvuk zvona je na vibraciji"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Zvuk obavještenja je isključen; obavještenja će vibrirati"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"Zvuk <xliff:g id="VOLUME_TYPE">%1$s</xliff:g> je isključen"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Nedostupno zbog isključenog zvona"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Melodija zvona telefona"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Zadani zvuk obavještenja"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvuk iz aplikacije"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Zadani zvuk obavještenja"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Zadani zvuk alarma"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Prvo vibriraj, a zatim postepeno zvoni"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Prostorni zvuk"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonovi tastature telefona"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvuk zaključavanja ekrana"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvukovi/vibracija prilikom punjenja"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvukovi priključne stanice"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Zvukovi dodira i klika"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Uvijek prikaži ikonu u načinu rada vibracije"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Zvučnik priključne stanice reprodukuje zvuk"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Svi zvukovi"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Samo zvukovi medijskih sadržaja"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Tišina"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonovi"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibracije"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Uključivanje zvukova"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Automatski titlovi"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatski titlovi za medije"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Žičane slušalice"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Zvuk iz kompatibilnih medija postaje prostraniji"</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{Nema}=1{Postavljen je 1 raspored}one{Postavljen je # raspored}few{Postavljena su # rasporeda}other{Postavljeno je # rasporeda}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ne ometaj"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Primajte obavještenja samo od važnih osoba i aplikacija"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Ograničite ometanja"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Uključi način rada Ne ometaj"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Zvuci alarma i medija mogu prekinuti"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Rasporedi"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Izbriši rasporede"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Izbriši"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Uredi"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Rasporedi"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Raspored"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Raspored"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Utišaj telefon u određeno vrijeme"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Postavite pravila za način rada Ne ometaj"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Raspored"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Koristi raspored"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Dozvoli ometanja koja proizvode zvuk"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokiranje vizuelnih ometanja"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Dozvolite vizualnu signalizaciju"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opcije prikaza za skrivena obavještenja"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kada je uključena funkcija Ne ometaj"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Bez zvuka obavještenja"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Obavještenja ćete vidjeti na ekranu"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Telefon neće zvoniti niti vibrirati kada stignu nova obavještenja."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Bez vizuelnih elemenata ili zvuka obavještenja"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Obavještenja nećete vidjeti niti čuti"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"U slučaju novih ili postojećih obavještenja, vaš telefon ih neće prikazivati, neće vibrirati niti zvoniti. Imajte na umu da će se i dalje prikazivati kritična obavještenja o aktivnosti i statusu uređaja.\n\nKada isključite funkciju Ne ometaj, propuštena obavještenja ćete pronaći prevlačenjem s vrha ekrana prema dolje."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Prilagođeno"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Omogući prilagođenu postavku"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Ukloni prilagođenu postavku"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Bez zvuka obavještenja"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Djelimično skriveno"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Bez vizuelnih elemenata ili zvuka obavještenja"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Prilagođena ograničenja"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Isključi zvuk i vibraciju"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Nemoj uključivati ekran"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Nemoj bljeskati"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nemoj isticati obavještenja na ekranu"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Sakrij ikone statusne trake na vrhu ekrana"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Sakrij tačke za obavještenja na ikonama aplikacija"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Nemoj aktivirati zbog obavještenja"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Sakrij s padajuće trake"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikada"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Zvuk i vibracija"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Zvuk, vibracija i neki vizuelni znakovi obavještenja"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvuk, vibracija i vizuelni znakovi obavještenja"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Obavještenja koja su potrebna za osnovne radnje i status uređaja se nikada neće sakriti."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Ništa"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"druge opcije"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Dodaj"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Uključi"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Uključi sada"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Isključi sada"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Način rada Ne ometaj će biti uključen do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Funkcija Ne ometaj će biti uključena dok je ne isključite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Način rada Ne ometaj je automatski uključen na osnovu rasporeda (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Način rada Ne ometaj je automatski uključila aplikacija (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Način rada Ne ometaj je uključen za <xliff:g id="RULE_NAMES">%s</xliff:g> zajedno sa zadanim postavkama."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Vidi prilagođene postavke"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Samo prioriteti"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Uključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Uključeno"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Pitaj svaki put"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Dok ne isključite"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 sat}one{# sat}few{# sata}other{# sati}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuta}one{# minuta}few{# minute}other{# minuta}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Isključeno}=1{Isključeno/1 raspored se može automatski uključiti}one{Isključeno/# raspored se može automatski uključiti}few{Isključeno/# rasporeda se mogu automatski uključiti}other{Isključeno/# rasporeda se može automatski uključiti}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Šta može prekinuti funkciju Ne ometaj"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Osobe"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikacije"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmi i druga ometanja"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Rasporedi"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Trajanje Brzih postavki"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Opće"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Kada je uključen način rada Ne ometaj, zvuk i vibracija će biti isključeni, osim za stavke koje omogućite iznad."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Prilagođene postavke"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Pregledajte raspored"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Razumijem"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Obavještenja"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trajanje"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Poruke, događaji i podsjetnici"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Kada je uključen način rada Ne ometaj, zvuk poruka, podsjetnika i događaja će se isključiti, osim za stavke kojim dozvolite iznad. Postavke poruka možete podesiti da omogućite prijateljima, porodici ili drugim kontaktima da vas kontaktiraju."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Gotovo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Postavke"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Bez vizuelnih elemenata ili zvuka obavještenja"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Bez zvuka obavještenja"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Obavještenja nećete vidjeti ili čuti. Dozvoljeni su pozivi od kontakata označenih zvjezdicom i ponovljenih pozivalaca."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Trenutna postavka)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Promijeniti postavke obavještenja načina rada Ne ometaj?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvukovi radnog profila"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Koristi zvukove ličnog profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Koristite iste zvukove kao za lični profil"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Melodija zvona radnog telefona"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Zadani zvuk radnih obavještenja"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Zadani zvuk radnog alarma"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Isto kao kod ličnog profila"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Koristiti zvukove ličnog profila?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Potvrdi"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Vaš radni profil će koristiti iste zvukove kao lični profil"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Obavještenja"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Historija obavještenja, razgovori"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Razgovor"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Upravljajte"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Obavještenja o aplikaciji"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Kontrolirajte obavještenja iz pojedinačnih aplikacija"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Opće"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Obavještenja za posao"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Radni profil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prilagodljivi prioritet obavještenja"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Obavještenja niskog prioriteta automatski će se postaviti na Diskretno"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Prilagodljivo rangiranje obavještenja"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automatski rangira obavještenja prema relevantnosti"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Povratne informacije o prilagodljivim obavještenjima"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Pokazivanje prilagođavanja obavještenja i prikaz opcije za pružanje povratnih informacija sistemu"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Poništavanje važnosti obavještenja"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Poništite postavke o važnosti koje je promijenio korisnik i dozvolite da asistent za obavještenja određuje prioritete"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Predložene radnje i odgovori"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automatski se prikazuju predložene radnje i odgovori"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Pregledajte nedavna i odgođena obavještenja"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historija obavještenja"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Koristi historiju obavještenja"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Historija obavještenja je isključena"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Uključite historiju obavještenja da vidite nedavna obavještenja i odgođena obavještenja"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nema nedavnih obavještenja"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Vaša nedavna i odgođena obavještenja će se pojaviti ovdje"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"prikaži postavke obavještenja"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"otvaranje obavještenja"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Dozvoli odgađanje obavještenja"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Tačka za obavještenja 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">"Vidite plutajuće ikone iznad 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">"Ako uključite oblačiće za ovu aplikaciju, također ćete uključiti oblačiće za svoj uređaj.\n\nTo će uticati na druge aplikacije ili razgovore kojima je dozvoljeno otvaranje oblačića."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Uključi"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Otkaži"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Uključeno / Razgovori se mogu pojaviti kao plutajuće ikone"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Dozvoli aplikacijama da prikazuju oblačiće"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Neki razgovori će se pojaviti kao plutajuće ikone iznad drugih aplikacija"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Svi razgovori se mogu prikazivati u oblačićma"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Odabrani razgovori se mogu prikazivati u oblačićima"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Ništa se ne može prikazivati u oblačićima"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Razgovori"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Svi razgovori se mogu pojaviti u oblačiću izuzev"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Isključite oblačiće za ovaj razgovor"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Uključite oblačiće za ovaj razgovor"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Prevucite udesno za odbacivanje, ulijevo za prikaz menija"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Prevucite ulijevo za odbacivanje, udesno za prikaz menija"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Sakrij nečujna obavještenja na statusnoj traci"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Trepćuće svjetlo"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privatnost"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Preskakanje zaključanog ekrana"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Nakon otključavanja idite direktno na posljednji korišteni ekran. Obavještenja se ne prikazuju na zaključanom ekranu. Prevucite nadolje da ih vidite."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"zaključaj ekran, zaljučavanje ekrana, preskoči, zaobilaženje"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kada je radni profil zaključan"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Prikazuj samo nova obavještenja na zaključanom ekranu"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Automatski uklonite prethodno prikazana obavještenja sa zaključanog ekrana"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Obavještenja na zaključanom ekranu"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Vidite razgovore, zadane i nečujne"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Prikaži zadane i nečujne razgovore"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Sakrij nečujne razgovore i obavještenja"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ne prikazuj nikakva obavještenja"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Obavještenja o osjetljivom sadržaju"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Prikaži osjetljiv sadržaj kada je uređaj zaključan"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Obavještenja o osjetljivom sadržaju radnog profila"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Prikaz osjetljivog sadržaja radnog profila kada je uređaj zaključan"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Prikaži sav sadržaj obavještenja"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Prikaži osjetljiv sadržaj samo kada je ekran otključan"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Uopće ne prikazuj obavještenja"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"Šta želite da vam zaključani ekran prikazuje?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Zaključani ekran"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Prikaži sav sadržaj obavještenja radnog profila"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Sakrij osjetljivi sadržaj radnog profila"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kada je uređaj zaključan, na koji način želite da se prikazuju obavještenja profila?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Obavještenja profila"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Obavještenja"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Obavještenja o aplikaciji"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategorija obavještenja"</string>
    <string name="notification_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">"Dozvolite aplikaciji da koristi odjeljak razgovora"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nije razgovor"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Uklonite 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 prioritetnih razgovora"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioritetan razgovor}one{# prioritetan 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 na vrhu odjeljka razgovora u vidu plutajućih oblačića"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Prikazuju se na 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 mijenjali"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nedavni razgovori"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Obriši nedavne razgovore"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Nedavni razgovori su uklonjeni"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Razgovor je uklonjen"</string>
    <string name="clear" msgid="5092178335409471100">"Obriši"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Brisanje razgovora <xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Ovdje će se prikazati prioritetni i promijenjeni razgovori"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Ovdje će se prikazati razgovori koje označite kao prioritetne i na kojima izvršite neke druge promjene. \n\nDa promijenite postavke razgovora: \nprevucite s vrha ekrana prema dolje da otvorite padajuću traku, a zatim dodirnite i zadržite razgovor."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimiziraj"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Prikaži na ekranu"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Nečujno"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Zadano"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Dozvoli ometanja"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"family link da aktivira zvuk, vibrira i/ili prikaže obavještenja na ekranu"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritetno"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Prikazuje se na vrhu odjeljka razgovora, pojavljuje se kao plutajući oblačić, prikazuje sliku profila na zaključanom ekranu"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> ne podržava većinu funkcija razgovora. Razgovor ne možete postaviti kao prioritetan i razgovori se neće pojavljivati kao plutajući oblačići."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Suzite obavještenja u jedan red na padajućoj traci"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Bez zvuka ili vibracije"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Bez zvuka ili vibracije i pojavljuje se pri dnu odjeljka razgovora"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Može zvoniti ili vibrirati na osnovu postavki uređaja"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kada je uređaj otključan, vidite obavještenja u vidu banera na vrhu ekrana"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Sva obavještenja aplikacije \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Sva obavještenja aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{O # obavještenju dnevno}one{O # obavještenju dnevno}few{O # obavještenja dnevno}other{O # obavještenja dnevno}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{O # obavještenju sedmično}one{O # obavještenju sedmično}few{O # obavještenja sedmično}other{O # obavještenja sedmično}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikada"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Obavještenja uređaja i aplikacija"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Kontrolirajte koje aplikacije i uređaji mogu čitati obavještenja"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Pristup obavještenjima radnog profila je blokiran"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Poboljšana obavještenja"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Primajte preporučene 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 obavještenjima."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Dozvoli pristup obavještenjima"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Poboljšana obavještenja su zamijenila Prilagodljiva obavještenja Androida u verziji Android 12. Ova funkcija prikazuje predložene radnje i odgovore te organizira vaša obavještenja. \n\nPoboljšana obavještenja mogu pristupiti sadržaju obavještenja, uključujući lične informacije kao što su imena kontakata i poruke. Ova funkcija također može odbacivati obavještenja ili reagirati na njih, npr. može odgovarati na telefonske pozive i kontrolirati funkciju Ne ometaj."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Dozvoliti aplikaciji <xliff:g id="SERVICE">%1$s</xliff:g> pristup obavještenjima?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Aplikacija <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> će moći čitati sva obavještenja, uključujući lične informacije kao što su imena kontakata, fotografije i tekst primljenih poruka. Ova aplikacija će također moći odgoditi ili odbaciti obavještenja ili djelovati na dugmad u obavještenjima, uključujući odgovaranje na telefonske pozive. \n\nNa ovaj način će se aplikaciji dati i mogućnost da uključi ili isključi funkciju Ne ometaj i mijenja postavke povezane s tom funkcijom."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Aplikacija <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> će moći:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"čitati vaša obavještenja"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Može čitati vaša obavještenja, uključujući lične podatke kao što su kontakti, poruke i fotografije."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"odgovarati na poruke"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Može odgovarati na poruke i djelovati na dugmad u obavještenjima, uključujući odgodu ili odbacivanje obavještenja i odgovaranje na pozive."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"mijenjati postavke"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Može uključiti ili isključiti opciju Ne ometaj i promijeniti postavke povezane s tom opcijom."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Ako aplikaciji <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> isključite pristup obavještenjima, može se isključiti i pristup načinu rada Ne ometaj."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Isključi"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Otkaži"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"U stvarnom vremenu"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Tekuća komunikacija iz aplikacija u upotrebi, navigacija, telefonski pozivi i drugo"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Razgovori"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, tekstualne poruke i ostali načini komunikacije"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Obavještenja"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Može zvoniti ili vibrirati na osnovu postavki"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Nečujno"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Obavještenja koja se nikada ne oglašavaju zvukom ili vibracijom"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Dozvoljeno"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nije dozvoljeno"</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 svaku aplikaciju koja šalje obavještenja"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplikacije prikazane na uređaju"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Ova aplikacija ne podržava poboljšane 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="notification_polite_title" msgid="6121016426991791557">"Mirovanje za obavještenja"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Primijeni mirovanje na sva obavještenja"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Postepeno smanjujte jačinu zvuka obavještenja kada dobijate previše uzastopnih obavještenja od iste aplikacije"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Primijeni mirovanje na razgovore"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Postepeno smanjujte jačinu zvuka obavještenja kada u kratkom periodu dobijate previše poruka od istog chata"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Nemoj koristiti mirovanje za obavještenja"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Jačina zvuka obavještenja se nikad ne smanjuje, bez obzira na količinu uzastopnih obavještenja od iste aplikacije"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Vibriraj kada je otključano"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Vibrira samo kada je ekran otključan"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Primijeni na poslovne profile"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Primijenite postavke mirovanja za obavještajna s ličnog profila na poslovni profil"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Usluge pomagača za VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nijedna instalirana aplikacija nije zatražila da bude pokrenuta kao usluga pomagača za VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Dozvoliti pristup usluzi VR-a za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> će moći raditi kada aplikacije budete koristili u načinu rada virtuelne realnosti."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Kada je uređaj u VR načinu rada"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Smanjenje zamućenosti (preporučeno)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Smanjenje treperenja"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Slika u slici"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Nijedna instalirana aplikacija ne podržava način rada 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">"Dozvoli sliku u slici"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Dozvolite aplikaciji da kreira prozor sa slikom u slici dok je aplikacija otvorena ili nakon što je napustite (npr. da nastavite gledati videozapis). Ovaj prozor se prikazuje preko drugih aplikacija koje koristite."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Povezane poslovne i lične aplikacije"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Povezano"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nije povezano"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nema povezanih aplikacija"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"više profila povezana aplikacija poslovne i lične aplikacije"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Povezano"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Poveži ove aplikacije"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Povezane aplikacije dijele odobrenja i mogu pristupati podacima uzajamno."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Povežite aplikacije samo ako ste uvjereni da neće dijeliti lične podatke s vašim IT administratorom."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Možete prekinuti povezanost s aplikacijama bilo kada u postavkama privatnosti uređaja."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Povjeriti lične podatke aplikaciji <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Povežite aplikacije samo ako ste uvjereni da neće dijeliti lične podatke s vašim IT administratorom."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Podaci aplikacije"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Ova aplikacija može pristupiti podacima u vašoj ličnoj aplikaciji <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Odobrenja"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Ova aplikacija može koristiti odobrenja vaše lične aplikacije <xliff:g id="NAME">%1$s</xliff:g>, kao što su pristup lokaciji, pohrani ili kontaktima."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nema povezanih aplikacija"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# aplikacija je povezana}one{# aplikacija je povezana}few{# aplikacije su povezane}other{# aplikacija je povezano}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Da povežete ove aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na radnom profilu"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Da povežete ove aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na ličnom profilu"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Dodirnite da preuzmete aplikaciju"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Pristup načinu rada Ne ometaj"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Dozvoli način rada Ne ometaj"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nijedna instalirana aplikacija nije zatražila pristup za Ne ometaj"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Niste dozvolili obavještenja iz ove aplikacije"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Na vaš zahtjev, Android blokira pojavljivanje ove kategorije obavještenja na ovom uređaju"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Na vaš zahtjev, Android blokira pojavljivanje ove grupe obavještenja na ovom uređaju"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Ova aplikacija ne šalje obavještenja"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorije"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Ostalo"</string>
    <string name="no_channels" msgid="4716199078612071915">"Ova aplikacija nije objavila nikakva obavještenja"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Dodatne postavke u aplikaciji"</string>
    <string name="show_unused_channels" msgid="2754356124204058828">"Prikaži nekorišt. kanale"</string>
    <string name="hide_unused_channels" msgid="9049958190570733200">"Sakrij nekorišt. kanale"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategorija je izbrisana}one{# kategorija je izbrisana}few{# kategorije su izbrisane}other{# kategorija je izbrisano}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokiraj sve"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Nikada ne prikazuj ova obavještenja"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Prikaži obavještenja"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nikad ne prikazuj obavještenja u nijansi ili na perifernim uređajima"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Dozvoli obavještenja preko cijelog ekrana"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Dozvolite obavještenjima da se prikažu preko cijelog ekrana kada je uređaj zaključan"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Dozvoli tačku za obavještenja"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Prikaži tačku za obavještenja"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Zanemari način rada Ne ometaj"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Dozvolite da se obavještenja nastave pojavljivati kada je uključen način rada Ne ometaj"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Zaključani ekran"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Gotovo"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Trepćuće svjetlo"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibracija"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Zvuk"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritetno"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Naziv rasporeda"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Unesite naziv rasporeda"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Naziv rasporeda se već koristi"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Dodajte još"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Dodajte raspored događaja"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"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">"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">"Ove postavke nije moguće sada promijeniti. Aplikacija (<xliff:g id="APP_NAME">%1$s</xliff:g>) je automatski uključila način rada Ne ometaj uz prilagođene postavke."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Ove postavke nije moguće sada promijeniti. Neka aplikacija je automatski uključila način rada Ne ometaj uz prilagođene postavke."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Ove postavke nije moguće sada promijeniti. Način rada Ne ometaj je ručno uključen uz prilagođene postavke."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Vrijeme"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Događaj"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Za vrijeme 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">"Ako je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Da, možda ili bez odgovora"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Da ili možda"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Da"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Pravilo nije pronađeno."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Uključen način rada / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Dani"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Ništa"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarm može prekoračiti vrijeme završetka"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Raspored će se isključiti kada se alarm aktivira"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Ponašanje načina rada Ne ometaj"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Koristite zadane postavke"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Kreirajte prilagođene postavke za ovaj raspored"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"\"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="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">"Nema"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Nema}=1{1 razgovor}one{# razgovor}few{# razgovora}other{# razgovora}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Ko vas može prekinuti"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Čak i ako vas aplikacije za razmjenu poruka ili pozivanje ne mogu obavijestiti, osobe koje ovdje odaberete će vas i dalje moći kontaktirati 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 vas mogu prekinuti"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Da biste se uvjerili da ćete čuti dozvoljene pozive, provjerite je li uređaj postavljen da zvoni"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Dolazni pozivi su blokirani za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Postavke možete podesiti da omogućite prijateljima, porodici ili drugim kontaktima da vas kontaktiraju."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontakti označeni zvjezdicom"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Nema}=1{{contact_1}}=2{{contact_1} i {contact_2}}=3{{contact_1}, {contact_2} i {contact_3}}one{{contact_1}, {contact_2} i još # kontakt}few{{contact_1}, {contact_2} i još # kontakta}other{{contact_1}, {contact_2} i još # kontakata}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Bez imena)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Poruke"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"poruke"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Poruke"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Poruke koje vas mogu prekinuti"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Da biste se uvjerili da ćete čuti dozvoljene poruke, provjerite je li uređaj postavljen da zvoni"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Dolazne poruke su blokirane za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Postavke možete podesiti da prijateljima, porodici ili drugim kontaktima dozvolite da vas kontaktiraju."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Primate sve poruke"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Primate sve pozive"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Nema}=1{1 kontakt}one{# kontakt}few{# kontakta}other{# kontakata}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Svako"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakti"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontakti označeni zvjezdicom"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Ništa"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Ništa"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmi"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Obavještenja tajmera, alarma, sigurnosnih sistema i drugih aplikacija"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmi"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmi"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Zvukovi medija"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Zvukovi iz videozapisa, igara i drugih medija"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"mediji"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Mediji"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Zvukovi dodira"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvukovi tastature i druge dugmadi"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvukovi dodira"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Zvukovi dodira"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Podsjetnici"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Obavještenja o zadacima i podsjetnicima"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"podsjetnici"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Podsjetnici"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Događaji u Kalendaru"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Obavještenja 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">"Dozvolite aplikacijama da zanemaruju"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikacije koje vas mogu prekinuti"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Odaberite još aplikacija"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nije odabrana nijedna aplikacija"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nijedna aplikacija ne može prekinuti"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Dodajte aplikacije"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Sva obavještenja"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Neka obavještenja"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Odabrane osobe vas i dalje mogu kontaktirati čak i ako ne dozvolite aplikacijama da vas prekidaju"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Nijedna aplikacija ne može prekinuti}=1{{app_1} može prekinuti}=2{{app_1} i {app_2} mogu prekinuti}=3{{app_1}, {app_2} i {app_3} mogu prekinuti}one{{app_1}, {app_2} i još # aplikacija mogu prekinuti}few{{app_1}, {app_2} i još # aplikacije mogu prekinuti}other{{app_1}, {app_2} i još # aplikacija mogu prekinuti}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikacije"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Obavještenja koja vas mogu prekinuti"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Dozvoli sva obavještenja"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Ništa ne može prekinuti}=1{{sound_category_1} može prekinuti}=2{{sound_category_1} i {sound_category_2} mogu prekinuti}=3{{sound_category_1}, {sound_category_2} i {sound_category_3} mogu prekinuti}one{{sound_category_1}, {sound_category_2} i još # zvuk mogu prekinuti}few{{sound_category_1}, {sound_category_2} i još # zvuka mogu prekinuti}other{{sound_category_1}, {sound_category_2} i još # zvukova mogu prekinuti}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Ništa ne može prekinuti"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Niko ne može prekinuti"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Neke osobe mogu prekinuti"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Sve osobe mogu prekinuti"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Ponovni pozivaoci"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Dozvoli ponovne pozivaoce"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"bilo ko"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontakti"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontakti označeni zvjezdicom"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"ponovljeni pozivaoci"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> i <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Ako ista osoba ponovo pozove u roku od <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Vrijeme početka"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Vrijeme završetka"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> sljedeći dan"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Pređi na postavku Samo alarmi na neodređeno vrijeme"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Promjena na alarme samo na jednu minutu do {time}}one{Promjena na alarme samo na # minutu (do {time})}few{Promjena na alarme samo na # minute (do {time})}other{Promjena na alarme samo na # minuta (do {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Promjena na alarme samo na jedan sat do {time}}one{Promjena na alarme samo na # sat do {time}}few{Promjena na alarme samo na # sata do {time}}other{Promjena na alarme samo na # sati do {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Pređi na postavku Samo alarmi do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Promijeniti u uvijek prekini"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Upozorenje"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Zatvori"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Slanje povratnih informacija o uređaju"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Upišite PIN administratora"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Uključeno"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Isključeno"</string>
    <string name="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">"Kačenje aplikacije"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Kačenje aplikacije omogućava da se trenutna aplikacija zadrži na ekranu dok je ne otkačite. Naprimjer, koristeći ovu funkciju možete omogućiti pouzdanom prijatelju da igra određenu igru."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Kada je aplikacija zakačena, ona može otvoriti druge aplikacije i omogućiti pristup ličnim podacima. \n\nDa koristite kačenje aplikacije: 	\n{0,number,integer}. Uključite kačenje aplikacije 	\n{1,number,integer}. Otvorite Pregled 	\n{2,number,integer}. Dodirnite ikonu aplikacije u gornjem dijelu ekrana, a zatim dodirnite Zakači"</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Kada je aplikacija zakačena, ona može otvoriti druge aplikacije i omogućiti pristup ličnim podacima. \n\nAko želite dijeliti uređaj s nekim na siguran način, pokušajte koristiti profil za gosta. \n\nDa koristite kačenje aplikacije: 	\n{0,number,integer}. Uključite kačenje aplikacije 	\n{1,number,integer}. Otvorite Pregled 	\n{2,number,integer}. Dodirnite ikonu aplikacije u gornjem dijelu ekrana, a zatim dodirnite Zakači"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kada je aplikacija zakačena: \n\n•		Lični podaci mogu biti dostupni \n		(kao što su kontakti i sadržaj e-pošte) \n•		Zakačena aplikacija može otvoriti druge aplikacije \n\nKačenje aplikacije koristite samo s osobama kojima vjerujete."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Traži uzorak za otključavanje prije poništavanja kačenja"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Traži PIN prije poništavanja kačenja"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Traži lozinku prije poništavanja kačenja"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Zaključaj uređaj kada se ekran otkači"</string>
    <string name="confirm_sim_deletion_title" msgid="7262127071183428893">"Potvrdite da želite potpuno izbrisati podatke eSIM-a"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Potvrdite identitet prije potpunog brisanja eSIM-a"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Beta v. Napredne zaštite memorije"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Napredna zaštita memorije"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Ova beta verzija funkcije vam pomaže da zaštitite uređaj od grešaka koje mogu ugroziti vašu 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">"Trenutno nije dostupno 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 uključite ili isključite Naprednu zaštitu memorije. Kada je uključena, možda ćete primijetiti sporije performanse uređaja."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Ponovo pokrenuti uređaj?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Morat ćete ponovo pokrenuti uređaj da uključite Naprednu zaštitu memorije."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Morat ćete ponovo pokrenuti uređaj da isključite Naprednu zaštitu memorije."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Ponovo pokreni"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Ne sada"</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 radnim profilom upravlja:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Profilom upravlja <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Zadano otvaranje"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Otvori podržane linkove"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Dozvolite otvaranje web linkova u ovoj aplikaciji"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Linkovi za otvaranje u ovoj aplikaciji"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podržani linkovi"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Ostale zadane postavke"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Dodajte link"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Aplikacija može potvrditi linkove da se automatski otvaraju u aplikaciji."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# potvrđen link}one{# potvrđen link}few{# potvrđena linka}other{# potvrđenih linkova}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Ovaj link je potvrđen i automatski se otvara u ovoj aplikaciji.}one{Ovi linkovi su potvrđeni i automatski se otvaraju u ovoj aplikaciji.}few{Ovi linkovi su potvrđeni i automatski se otvaraju u ovoj aplikaciji.}other{Ovi linkovi su potvrđeni i automatski se otvaraju u ovoj aplikaciji.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"Uredu"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Prikaz liste potvrđenih linkova"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Provjeravanje drugih podržanih linkova…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Otkaži"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# podržan link}one{# podržan link}few{# podržana linka}other{# podržanih linkova}}"</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">"unutrašnja pohrana"</string>
    <string name="storage_type_external" msgid="125078274000280821">"vanjska pohrana"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"Iskorišt.: <xliff:g id="SIZE">%1$s</xliff:g> od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Iskorištena memorija"</string>
    <string name="change" msgid="273206077375322595">"Izmijeni"</string>
    <string name="change_storage" msgid="8773820275624113401">"Promijeni pohranu"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Obavještenja"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Uključeno"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Isključeno"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategorija je isključena}one{# kategorija je isključena}few{# kategorije su isključene}other{# kategorija je isključeno}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# dodatno odobrenje}one{# dodatno odobrenje}few{# dodatna odobrenja}other{# dodatnih odobrenja}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nema dodijeljenih odobrenja"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nema zatraženih odobrenja"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Kontrolirajte pristup aplikacija podacima"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Kontrolna tabla za privatnost"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Prikaz aplikacija koje su nedavno koristile odobrenja"</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 za nekorištene aplikacije"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pauziraj aktivnost apl. ako se ne koristi"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Uklonite odobrenja, izbrišite privremene fajlove i zaustavite obavještenja"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Upravljanje aplikacijom ako se ne koristi"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Uklonite odobrenja, izbrišite privremene fajlove, zaustavite obavještenja i arhivirajte aplikaciju"</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">"Napredno"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Upravitelj odobrenja"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Promjene u 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 podatke o vašoj lokaciji"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Dodirnite za buđenje"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dva puta dodirnite bilo gdje na zaslonu da probudite uređaj"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Otvaranje linkova"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ne otvaraj podržane linkove"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Otvori <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Otvori <xliff:g id="DOMAIN">%s</xliff:g> i druge URL-ove"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Dozvolite aplikaciji da otvara podržane linkove"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Pitaj svaki put"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Nemoj dozvoliti aplikaciji da otvara linkove"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplikacija polaže pravo da obrađuje # link}one{Aplikacija polaže pravo da obrađuje # link}few{Aplikacija polaže pravo da obrađuje # linka}other{Aplikacija polaže pravo da obrađuje # linkova}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikacija polaže pravo da obrađuje sljedeće linkove:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Pomoć i glasovni unos"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Aplikacija digitalnog asistenta"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Zadani digitalni asistent asistenta"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Pristajem"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Aplikacija preglednika"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikacija za telefon"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistem)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Pohrana aplikacija"</string>
    <string name="usage_access" msgid="5487993885373893282">"Pristup korištenju"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Dopusti pristup korištenju"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Vrijeme korištenja uređaja"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Pristup korištenju omogućava praćenje drugih aplikacija koje koristite i učestalosti korištenja, kao i praćenje vašeg operatera, postavki jezika i drugo."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memorija"</string>
    <string name="always_running" msgid="9012705720688200252">"Uvijek je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Ponekad je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Rijetko u funkciji (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_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">"Bez optimizacije"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Nije optimizirano"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizacija potrošnje baterije"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimizacija baterije je nedostupna"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Dozvoliti aplikaciji da uvijek radi u pozadini?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Ako aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> dozvolite da uvijek radi u pozadini, može se skratiti vijek trajanja baterije. \n\nOvo možete kasnije promijeniti u odjeljku Postavke &gt; Aplikacije."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> iskorištenosti od posljednje potpune napunjenosti"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"Potrošnja u posljednja 24 sata: <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Nema potrošnje baterije od prošlog potpunog punjenja"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Podijeliti izvještaj o grešci?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Vaš IT administrator je zatražio izvještaj o grešci kako bi pomogao u rješavanju problema ovog uređaja. Može doći do dijeljenja aplikacija i podataka."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Vaš IT administrator je zatražio izvještaj o grešci kako bi pomogao u rješavanju problema na ovom uređaju. To može uzrokovati dijeljenje aplikacija i podataka te privremeno usporiti vaš uređaj."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Ovaj izvještaj o grešci se dijeli sa vašim IT administratorom. Kontaktirajte ga da dobijete više informacija."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Podijelite"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Odbij"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Nema prijenosa podataka"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Punjenje povezanog uređaja"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Prijenos fajlova"</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">"Konverzija videozapisa u AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videozapisi će se reproducirati na više medija plejera, ali se kvalitet može smanjiti"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Dijeljenje internetske veze putem USB-a"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Koristite USB za"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Zadana USB konfiguracija"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Kada se poveže drugi uređaj i vaš telefon je otključan, primijenit će se ove postavke. Povežite se samo s pouzdanim uređajima."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Opcije napajanja"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opcije prijenosa fajlova"</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 fajlova"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Dijeljenje internetske veze putem USB-a"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Web kamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Prijenos fajlova i napajanje"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Dijeljenje internetske veze putem USB-a i napajanje"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP i napajanje"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI i napajanje"</string>
    <string name="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">"Korištenje teksta s ekrana"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Omogućava aplikaciji za pomoć da pristupa sadržaju na ekranu kao tekstu"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Korištenje snimke ekrana"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Omogućava aplikaciji za pomoć da pristupa slici ekrana"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Bljeskanje ekrana"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Ivice ekrana bljeskaju kada aplikacija za pomoć pristupi tekstu s ekrana ili snimku ekrana"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Aplikacije za pomoć vam mogu pomoći na osnovu informacija s ekrana koji pregledate. Kako bi vam pružile sveukupnu pomoć, neke aplikacije podržavaju i usluge pokretača i glasovnog unosa."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Prosječna iskorištenost memorije"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimalna upotreba memorije"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Korištenje memorije"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Korištenje aplikacija"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalji"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> memorije korišteno u prosjeku u zadnja 3 sata"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Nikakva memorija se ne koristi u posljednja tri sata"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Poredaj po prosječnoj upotrebi"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Poredaj po maksimalnom korištenju"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Performanse"</string>
    <string name="total_memory" msgid="5244174393008910567">"Ukupno memorije"</string>
    <string name="average_used" msgid="690235917394070169">"Prosječna iskorištenost (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Slobodno"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memorija koju koriste aplikacije"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 aplikacija je koristila memoriju u posljednjem periodu: {time}}one{# aplikacija je koristila memoriju u posljednjem periodu: {time}}few{# aplikacije su koristile memoriju u posljednjem periodu: {time}}other{# aplikacija je koristilo memoriju u posljednjem periodu: {time}}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Omogući profiliranje korištenja memorije"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"Profiliranje korištenja memorije zahtijeva dodatne izvore sistema."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Profiliranje memorije je onemogućeno"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frekvencija"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimalno korištenje"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Nema iskorištenih podataka"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Dozvoliti da <xliff:g id="APP">%1$s</xliff:g> pristupa načinu rada Ne ometaj?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikacija će biti u mogućnosti da uključi/isključi način rada Ne ometaj i izmijeni povezane postavke."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Mora ostati uključeno jer je uključen pristup obavještenjima"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Opozvati pristup funkciji Ne ometaj za aplikaciju <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Sva pravila za funkciju Ne ometaj koje je kreirala ova aplikacija će se ukloniti."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ne optimiziraj"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizuj"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Baterija se može brže isprazniti. Aplikaciji više neće biti ograničena potrošnja baterije u pozadini."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Preporučuje se za duže trajanje baterije"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Ništa"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Isključivanjem pristupa korištenju za ovu aplikaciju nećete spriječiti administratora da prati podatke o korištenju u aplikacija u vašem radnom profilu."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Prikaz preko drugih aplikacija"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Dozvoli prikaz preko drugih aplikacija"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Dozvolite ovoj aplikaciji da prekrije ostale aplikacije koje koristite. Ova aplikacija će moći vidjeti gdje dodirujete ili promijeniti ono što je prikazano na ekranu."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Promijeni izlaz med. sadržaja"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Dozvoli apl. da prebacuje izlaz med. sadržaja"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Dozvoljava ovoj aplikaciji da odabere koji povezani uređaj reproducira zvuk ili videozapis iz drugih aplikacija. Ako je dozvoljeno, ova aplikacija može pristupiti listi dostupnih uređaja kao što su slušalice i zvučnici te odabrati koji izlazni uređaj se koristi za prijenos ili emitiranje zvuka ili videozapisa."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Pristup svim fajlovima"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Dozvoli pristup za upravljanje svim fajlovima"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Dozvolite ovoj aplikaciji da čita, mijenja i briše sve fajlove na ovom uređaju ili svim povezanim uređajima za pohranu. Ako to dozvolite, aplikacija može pristupati fajlovima bez vašeg znanja."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Može da pristupa svim fajlovima"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Aplikacije s glasovnom aktivacijom"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Dozvoli glasovnu aktivaciju"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Glasovna aktivacija pomoću glasovne komande bez dodira uključuje odobrene aplikacije. Ugrađena prilagodljiva detekcija osigurava da vaši podaci ostanu privatni.\n\n"<a href="">"Više o sigurnoj prilagodljivoj detekciji"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Obavještenja preko cijelog ekrana"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Dozvoli obavještenja ove aplikacije preko cijelog ekrana"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Dozvolite aplikaciji da prikazuje obavještenja koja zauzimaju cijeli ekran kada je uređaj zaključan. Aplikacije ih mogu koristiti da istaknu alarme, dolazne pozive ili druga hitna obavještenja."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplikacije za upravljanje medijima"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Dozvoli apl. da upravlja medijskim fajlovima"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Ako je dozvoljeno, ova aplikacija bez vašeg odobrenja može mijenjati ili brisati medijske fajlove kreirane pomoću drugih aplikacija. Aplikacija mora imati odobrenje za pristup fajlovima i medijima."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"medijski fajlovi, fajl, upravljanje, upravitelj, upravljati, urediti, uređivač, aplikacija, program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr slušalac virtuelne realnosti stereo pomoćna usluga"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Prikaz preko drugih aplikacija"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikacije s odobrenjem"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Dozvoljeno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nije dozvoljeno"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instaliranje aplikacije nepoznati izvori"</string>
    <string name="write_settings" msgid="6864794401614425894">"Izmjena postavki sistema"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"pisati izmijeniti sistemske postavke"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Mogu instalirati druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Mogu mijenjati postavke sistema"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Mogu mijenjati postavke sistema"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Izmjeni postavke sistema"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Dozvoli izmjenu postavki sistema"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Ovo odobrenje omogućava aplikaciji da izmijeni postavke sistema."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Dozvoli iz ovog izvora"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Dvostruko uvrtanje za otvaranje kamere"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Da biste otvorili aplikaciju za kameru, dva puta uvrnite zglob"</string>
    <string name="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">"gustoća prikaza, uvećanje ekrana, promijeni veličinu, mijenjanje veličine"</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 povezano"</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">"Iskorišteno <xliff:g id="PERCENTAGE">%1$s</xliff:g> - Slobodno <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tamna tema, veličina fonta, osvjetljenje"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Iskorišteno prosječno <xliff:g id="USED_MEMORY">%1$s</xliff:g> od ukupno <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prijavljeni ste kao <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="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 je radnim pravilima"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Nije moguće promijeniti jačinu zvuka"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Upućivanje poziva nije moguće"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Slanje SMS poruka nije moguće"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Korištenje kamere nije moguće"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Izrada snimaka ekrana nije moguća"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Nije moguće otvoriti aplikaciju"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokirao vaš dobavljač uređaja na kredit"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Potreban je roditelj"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Predaj telefon roditelju da započne postavljanje"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Daj telefon roditelju da dozvoli promjenu ove postavke."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Za više informacija kontaktirajte IT administratora"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Više detalja"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Vaš administrator može pratiti i upravljati aplikacijama i podacima povezanim s vašim radnim profilom, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Vaš administrator može pratiti i upravljati aplikacijama i podacima koji su povezani s ovim korisnikom, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Vaš administrator može pratiti i upravljati aplikacijama i podacima koji su povezani s ovim uređajem, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Administrator uređaja će moći pristupiti podacima povezanim s ovim uređajem, upravljati aplikacijama i promijeniti njegove postavke."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Isključi"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Uključi"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Prikaži"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Sakrij"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Pristupna tačka je aktivna"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Način rada u avionu je uključen"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Mreže nisu dostupne"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Uključen način rada Ne ometaj"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Zvuk na telefonu je isključen"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"S izuzecima"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Ušteda baterije je uključena"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funkcije su ograničene"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Prijenos podataka na mobilnoj mreži je isključen"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet je dostupan samo putem WiFi-ja"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Ušteda podataka"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funkcije su ograničene"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Radni profil je isključen"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Za aplikacije i obavještenja"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Uključi zvuk"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Zvuk zvona je isključen"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Za pozive i obavještenja"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Samo vibracija"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Za pozive i obavještenja"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Postavite plan za Noćno svjetlo"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Automatski oboji ekran svaku noć"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Noćno svjetlo je uključeno"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Ekran ima žutu nijansu"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Nijanse sive"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Prikaži samo u sivoj boji"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Suzi"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Hladna temperatura boje"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Koristite hladnije boje prikaza"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Isključite ekran kako biste primijenili promjenu boje"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Laserski senzor kamere"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatska ažuriranja sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Primijenite ažuriranja nakon što se uređaj ponovo pokrene"</string>
    <string name="usage" msgid="287782903846013936">"Potrošnja"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Prijenos podataka u aplikaciji"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Prijenos podataka putem WiFi-ja"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Prijenos podataka mimo mobilnog operatera"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Prijenos podataka putem Etherneta"</string>
    <string name="wifi" msgid="2932584495223243842">"WiFi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> putem prijenosa podataka"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> WiFi podataka"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> ethernet podataka"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Upozorenje o prijenosu pod. i ograničenje"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciklus prijenosa podataka na mob. mreži"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Upozorenje o prijenosu podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Ograničenje prijenosa podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Upozorenje o prijenosu podataka: <xliff:g id="ID_1">^1</xliff:g> / Ograničenje prijenosa podataka: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Ne obuhvata podatke koje koriste mreže mobilnog operatera"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Iskorišteno je <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Postavi upozor. o prij. podat."</string>
    <string name="data_warning" msgid="2925054658166062884">"Upozorenje o prijenosu podataka"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Uređaj mjeri upozorenje o prijenosu podataka i ograničenje prijenosa podataka. Ovo se može razlikovati od prijenosa podataka kojeg je izmjerio mobilni operater."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Postavi ogranič. prij. podat."</string>
    <string name="data_limit" msgid="8731731657513652363">"Ograničenje prijenosa podataka"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> iskorišteno <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfiguracija"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Ostale aplikacije uključene u korištenje"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 aplikacija smije upotrebljavati neograničene podatke kada je Ušteda podataka uključena}one{# aplikacija smije upotrebljavati neograničene podatke kada je Ušteda podataka uključena}few{# aplikacije smiju upotrebljavati neograničene podatke kada je Ušteda podataka uključena}other{# aplikacija smije upotrebljavati neograničene podatke kada je Ušteda podataka uključena}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primarni plan prijenosa podataka"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Wi‑Fi podaci"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Iskorišteno je <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Prekoračenje: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Još <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafikon koji prikazuje potrošnju prijenosa podataka od <xliff:g id="START_DATE">%1$s</xliff:g> do <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Nema potrošnje prijenosa podataka u ovom rasponu datuma"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Preostao je još # dan}one{Preostao je još # dan}few{Preostala su još # dana}other{Preostalo je još # 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 mob. operater <xliff:g id="ID_1">^1</xliff:g> prije <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Ažurirano prije <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Upravo ažurirao mob. operater <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Upravo ažurirano"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Prikaži detalje"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Ušteda podataka"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neograničen prijenos podataka"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Pozadinski podaci su isključeni"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Uključeno"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Isključeno"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Koristi Uštedu podataka"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neograničen prijenos podataka"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Dozvolite neograničen pristup podacima kada je uključena Ušteda podataka"</string>
    <string name="home_app" msgid="6056850504746902747">"Aplikacija na početnom ekranu"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Dodajte još jedan otisak prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Otključajte nekim drugim prstom"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Uključeno"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Uključit će se na <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Isključeno"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Potrošnja baterije za aplikaciju"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Postavite potrošnju baterije za aplikacije"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Prikaži postavke"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Provjerite"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Razumijem"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Je li ova poruka korisna?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Ikona upozorenja sa savjetima za bateriju"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Uključite prilagodljivu osvijetljenost da produžite vijek trajanja baterije"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Smanjite istek vremena ekrana da produžite vijek trajanja baterije"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"Aplikacija <xliff:g id="APP_LABEL">%1$s</xliff:g> je potrošila više baterije"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"Aplikacija <xliff:g id="APP_LABEL">%1$s</xliff:g> je potrošila više baterije nego inače"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"Aplikacija <xliff:g id="APP_LABEL">%1$s</xliff:g> je potrošila više baterije pri radu u pozadini"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"Aplikacija <xliff:g id="APP_LABEL">%1$s</xliff:g> je potrošila više baterije nego inače pri radu u pozadini"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"Aplikacija <xliff:g id="APP_LABEL">%1$s</xliff:g> je potrošila više baterije pri radu u prvom planu"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"Aplikacija <xliff:g id="APP_LABEL">%1$s</xliff:g> je potrošila više baterije nego inače pri radu u prvom planu"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Nepravilnost u potrošnji baterije"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Visoka potrošnja baterije"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Visoka potrošnja baterije u pozadini"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Visoka potrošnja baterije u prvom planu"</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">"Odaberite provjeru pravopisa"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Koristi provjeru pravopisa"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nije odabrano"</string>
    <string name="notification_log_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">"javnaVerzija"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"važnost"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"objašnjenje"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"može prikazati značku"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"namjera"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"izbrisati namjeru"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"namjera za cijeli ekran"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"akcije"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"naslov"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"daljinski unosi"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"prilagođeni prikaz"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"dodaci"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"veličina paketa"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"izdato obavještenje"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Rangirani objekt nedostaje."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Rangirani objekt ne sadrži ovu tipku."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Urez u ekranu"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"urez ekrana, urez"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Zadana postavka uređaja"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Primjena preklapanja nije uspjela"</string>
    <string name="special_access" msgid="1767980727423395147">"Poseban pristup za aplikacije"</string>
    <string name="special_access_more" msgid="132919514147475846">"Prikaži više"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Dugi zadaci u pozadini"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Dozvoli dugo izvršavanje zadataka u pozadini"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Dugi zadaci u pozadini"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Dozvolite ovoj aplikaciji da izvršava duge zadatke u pozadini. Ovo omogućava aplikaciji da izvršava zadatke za koje može biti potrebno više od nekoliko minuta, kao što su preuzimanja i otpremanja. \n\nAko se ovo odobrenje odbije, sistem će odrediti granicu za to koliko dugo aplikacija može izvršavati takve zadatke u pozadini."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"dugi zadaci, prijenos podataka, zadaci u pozadini"</string>
    <string name="run_backup_tasks_title" msgid="8572480651659803275">"Izvršavanje zadataka izrade sigurnosne kopije u pozadini"</string>
    <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Dozvoli aplikaciji da izvršava zadatke povezane s izradom sigurnosne kopije u pozadini"</string>
    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Pokazuje da se aplikacija intenzivno koristi kada treba napraviti sigurnosnu kopiju sadržaja ili ga sinhronizirati. Ako date odobrenje aplikaciji, dozvolit ćete joj da radi u pozadini malo duže da izvrši zadatke povezane s izradom sigurnosne kopije. \n\nAko odbijete odobrenje aplikaciji, sistem joj neće omogućiti nikakav poseban izuzetak da izvrši zadatke povezane s izradom sigurnosne kopije u pozadini."</string>
    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"izrada sigurnosne kopije zadataka, izrada sigurnosne kopije poslova"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Poništi ograničenje brzine ShortcutManagera"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Ograničenje brzine ShortcutManagera je poništeno"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrolirajte informacije na zaključanom ekranu"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Pokaži ili sakrij sadržaj obavještenja"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Savjeti i podrška"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Najmanja širina"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nijedna instalirana aplikacija nije zatražila pristup premijum SMS-ovima"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Usluga Premium SMS se možda dodatno plaća te će trošak biti na računu koji dobijate od operatera. Ukoliko aplikaciji date odobrenje, moći ćete slati premium SMS poruke putem te aplikacije."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Pristup premijum SMS-ovima"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Isključeno"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Povezano s mrežom <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Povezan s više uređaja"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Demo način rada Sistemskog UI-ja"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tamna tema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Privremeno onemogućeno zbog Uštede baterije"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Privremeno onemogućeno zbog uštede baterije"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Isključi uštedu baterije"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Privremeno uključeno zbog Uštede baterije"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Isprobajte tamnu temu"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pomaže da se produži vijek trajanja baterije"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Pločice programera za brze postavke"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Onemogući istek vremena za ADB ovlaštenje"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Onemogućite automatsko ukidanje ADB ovlaštenja za sisteme koji se nisu ponovo povezali u zadanom roku (7 dana) ili u roku koji je konfigurirao korisnik (minimalno 1 dan)."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Senzori su isključeni"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Postavke radnog profila"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Pretražujte kontakte iz poslovnog imenika u ličnim aplikacijama"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Vaša pretraživanja i dolazni pozivi mogu biti vidljivi vašem IT administratoru"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendar za više profila"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Prikaz poslovnih događaja u ličnom kalendaru"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Kada su poslovne aplikacije isključene, pauzirane su i ne može im se pristupiti niti vam mogu slati obavještenja"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Upravljanje prostorom za pohranu"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Radi lakšeg oslobađanja prostora za pohranu, upravitelj pohranom s vašeg uređaja uklanja sigurnosne kopije fotografija i videozapisa."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Ukloni fotografije i videozapise"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Upravitelj prostora za pohranu"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Koristi Upravitelja pohrane"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Pokreti"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Brzo otvaranje kamere"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Da brzo otvorite kameru, dvaput pritisnite dugme za uključivanje. Funkcionira na svim ekranima."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Obrtanje kamere za selfi"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Način rada za navigaciju"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigacija pomoću 2 dugmeta"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Da prebacite aplikacije, na dugmetu za početni ekran prevucite prema gore. Za prikaz svih aplikacija, ponovo prevucite prema gore. Dodirnite dugme za povratak da se vratite."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Sigurnost i hitni pozivi"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Hitni pozivi, zdravstveni podaci, obavještenja"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigacija pokretima"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Da odete na početni ekran, prevucite prema gore s dna ekrana. Da se prebacite na drugu aplikaciju, prevucite s dna prema gore, zadržite, a zatim otpustite. Da se vratite, prevucite s lijevog odnosno desnog ruba."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigacija pomoću 3 dugmeta"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Da se vratite, odete na početni ekran i pebacite iz jedne aplikacije u drugu, koristite dugmad u dnu ekrana."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigacija za sistem, navigacija pomoću 2 dugmeta, navigacija pomoću 3 dugmeta, navigacija pokretima, prevlačenje"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitalni asistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Prevucite da pozovete asistenta na radnju"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Prevucite s donjeg ugla prema gore da pozovete na radnju aplikaciju digitalnog asistenta"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Zadržavanje dugmeta za početni ekran za Asistenta"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Pritisnite i zadržite dugme za početni ekran da aktivirate aplikaciju digitalnog asistenta."</string>
    <string name="low_label" msgid="6525629096999711220">"Nisko"</string>
    <string name="high_label" msgid="357503396626018487">"Visoko"</string>
    <string name="left_edge" msgid="1513576842959071849">"Lijeva ivica"</string>
    <string name="right_edge" msgid="1505309103265829121">"Desna ivica"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Veća osjetljivost može izazvati probleme prilikom korištenja pokreta aplikacija uz ivice ekrana."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Osjetljivost pokreta za povratak"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Osjetljivost navigacije pokretima"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigacija pomoću dugmeta"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigacija pokretima, osjetljivost pokreta za povratak, pokret za povratak"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigacija, dugme za početni ekran"</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čica za način rada jednom rukom"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"mogućnost dosega"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Prevucite nadolje za:"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Koristite prečicu za"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Povucite nadolje gornju polovinu ekrana da se lakše dosegne jednom rukom"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Kako koristiti način rada jednom rukom:"</b>\n" • Provjerite je li u sistemskim postavkama navigacije odabrana navigacija pokretima.\n • Prevucite nadolje blizu donjeg ruba ekrana."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Povlačenje ekrana da bude u dosegu"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Vrh ekrana će se pomjeriti da ga možete dosegnuti palcem."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Prikaz obavještenja"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Obavještenja i postavke će se prikazati."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Da provjerite vrijeme, obavještenja i druge informacije, dvaput dodirnite ekran."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Aktiviranje ekrana"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Da provjerite vrijeme, obavještenja i druge informacije, dodirnite ekran."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Hitni pozivi"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Koristi hitne pozive"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Brzo pritisnite dugme za uključivanje 5 ili više puta da pokrenete radnje ispod"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Reproduciraj alarm s odbrojavanjem"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Reproduciranje glasnog zvuka prilikom pokretanja hitnih poziva"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Slanje obavještenja radi pomoći"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Poziv za pomoć"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Broj za pomoć"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Dodirnite da promijenite"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Ako unesete broj koji nije za hitne slučajeve:\n • vaš uređaj mora biti otključan da koristite hitne pozive\n • moguće je da niko ne odgovori na poziv"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Prevlačenje prstom za obavještenja"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Prevlačenje prstom"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Brzo pregledajte obavještenja"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Uključeno"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Isključeno"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Program za učitavanje operativnog sistema je već otključan"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Povežite se na internet ili kontaktirajte svog operatera"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nedostupno na uređajima koje je zaključao operater"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Ponovo pokrenite uređaj da omogućite funkciju zaštite uređaja."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> je ukupno na raspolaganju\n\nPosljednji put je pokrenuto <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant aplikacije"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Otvaranje linkova u aplikacijama, čak i ako nisu instalirane"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant aplikacije"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Postavke instant aplikacija"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Instalirane aplikacije"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Vašom pohranom sada upravlja upravitelj pohrane"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Računi korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automatska sinhronizacija podataka aplikacija"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Dozvolite aplikacijama da automatski osvježavaju podatke"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sinhronizacija računa"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinhronizacija je uključena za stavke: <xliff:g id="ID_1">%1$d</xliff:g> od <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinhronizacija je uključena za sve stavke"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinhronizacija je isključena za sve stavke"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Podaci o uređaju kojim se upravlja"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Promjene i postavke kojima upravlja vaša organizacija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Promjene i postavke kojima upravlja organizacija <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Za davanje pristupa vašim radnim podacima, vaša organizacija može na vašem uređaju promijeniti postavke i instalirati softver.\n\nZa više informacija, obratite se administratoru vaše organizacije."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Vrste informacija koje vaša organizacija može vidjeti"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Izmjene koje je izvršio adminstrator vaše organizacije"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Vaš pristup ovom uređaju"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Podaci koji su povezani s vašim računom, kao što su e-pošta ili kalendar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lista aplikacija na vašem uređaju"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Utrošeno vrijeme i podaci za svaku aplikaciju"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Najskoriji zapis mrežnog saobraćaja"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Najnoviji izvještaj o greškama"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Najnoviji zapisnik o aktivnostima"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"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 je samo procjena. Možda nisu obuhvaćene aplikacije koje su instalirane izvan Play trgovine."</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">"Odobrenja za lokacije"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Odobrenja za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Odobrenja za kameru"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Zadane aplikacije"</string>
    <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 tastatura"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Postavljeno kao <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Uključen je uvijek aktivni VPN"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Uvijek aktivni VPN je uključen u vašem ličnom profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Uvijek aktivni VPN je uključen u vašem radnom profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Globalno postavljanje za HTTP proksi"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Pouzdani akreditivi"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Pouzdani akreditivi na vašem ličnom profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Pouzdani akreditivi na vašem radnom profilu"</string>
    <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 postaviti novu lozinku"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administrator može izbrisati sve podatke iz uređaja"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Neuspjeli pokušaji upisivanja lozinke prije brisanja svih podataka na uređaju"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Neuspjeli pokušaji upisivanja lozinke prije brisanja svih podataka radnog profila"</string>
    <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">"Zabranjena postavka"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Ograničene postavke su dozvoljene 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 postavka je trenutno nedostupna."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informacije o finansiranom uređaju"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Vaš dobavljač uređaja na kredit može promijeniti postavke i instalirati softver na ovom uređaju tokom postavljanja.\n\nAko propustite plaćanje, dobavljač uređaja na kredit može zaključati uređaj i promijeniti postavke uređaja.\n\nDa saznate više, kontaktirajte dobavljača uređaja na kredit."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Ako je vaš uređaj finansirani uređaj, ne možete:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"instalirati aplikacije izvan Play trgovine"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"ponovo pokrenuti uređaj u sigurnom načinu rada"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"dodati više korisnika na uređaj"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"promijeniti datum, vrijeme i vremenske zone"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"koristiti opcije za programere"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Vaš dobavljač uređaja na kredit može:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"pristupiti vašem IMEI broju"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"vratiti uređaj na fabričke postavke ako nešto ne bude uredu"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Ako se vaš uređaj zaključa, možete samo:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"uspostavljati hitne pozive"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"pregledati informacije o sistemu kao što su datum, vrijeme, status mreže i podaci o bateriji"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"uključiti ili isključiti uređaj"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"pregledati obavještenja i tekstualne poruke"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"pristupati aplikacijama koje je dozvolio dobavljač uređaja na kredit"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Kada platite cjelokupni 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">"možete deinstalirati aplikaciju povjerioca"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Informacije o finansiranom uređaju"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Aplikacija za kameru}one{Aplikacije za kameru}few{Aplikacije za kameru}other{Aplikacije za kameru}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikacija za kalendar"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikacija za kontakte"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Aplikacija klijenta za e-poštu}one{Aplikacije klijenta za e-poštu}few{Aplikacije klijenta za e-poštu}other{Aplikacije klijenta za e-poštu}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikacija za mape"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Aplikacija za telefon}one{Aplikacije za telefon}few{Aplikacije za telefon}other{Aplikacije za telefon}}"</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">"Fajlovi"</string>
    <string name="storage_images" msgid="2055893015567979387">"Slike"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videozapisi"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Zvuk"</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">"Sistem"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Otpad"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Isprazniti otpad?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Fajlovi u otpadu zauzimaju <xliff:g id="TOTAL">%1$s</xliff:g>. Sve stavke će se trajno izbrisati 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 je <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">"Obriši aplikaciju"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Želite li ukloniti ovu instant aplikaciju?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Otvori"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Igre"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Iskorišteni prostor"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(deinstalirano za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(onemogućeno za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Usluga automatskog popunjavanja"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Zadana usluga automatskog popunjavanja"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Lozinke"</string>
    <string name="credman_chosen_app_title" msgid="7735183808067729319">"Željena usluga"</string>
    <string name="credman_credentials" msgid="2620352336624160642">"Dodatne usluge"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# lozinka}one{# lozinka}few{# lozinke}other{# lozinki}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatski, popunjavanje, automatsko popunjavanje, lozinka"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"podaci, pristupni ključ, lozinka"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatski, popuniti, automatsko popunjavanje, podaci, pristupni ključ, lozinka"</string>
    <string name="credman_button_change" msgid="4072629639218503790">"Promijenite"</string>
    <string name="credman_button_open" msgid="7519871964170816850">"Otvori"</string>
    <string name="credman_app_list_preference_none" msgid="2509646651254971448">"Nije ništa odabrano"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Provjerite je li ova aplikacija pouzdana&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Automatsko popunjavanje&gt;%1$s&lt;/xliff:g&gt; koristi sadržaj na vašem ekranu da odredi šta se može automatski popuniti."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Koristite aplikaciju &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Nove lozinke, pristupni ključevi i druge informacije će se odsad pohranjivati ovdje. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; može koristiti ono što je na ekranu da utvrdi šta se može automatski popuniti."</string>
    <string name="credman_picker_title" msgid="8442086614222006564">"Željena usluga za lozinke, pristupne ključeve i automatsko popunjavanje"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Isključiti %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Isključiti uslugu?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Sačuvane informacije kao što su lozinke, pristupni ključevi, načini plaćanja i druge informacije se neće popunjavati prilikom prijave. Da koristite sačuvane informacije, odaberite lozinku, pristupni ključ ili uslugu za podatke."</string>
    <string name="account_dashboard_title_with_passkeys" msgid="6214673787161409996">"Lozinke, prist. ključevi i autom. popunjav."</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Isključiti sve usluge?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Lozinke, pristupni ključevi i druge sačuvane informacije neće biti dostupne za automatsko popunjavanje kada se prijavite"</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&lt;b&gt;Promijenite željenu uslugu u &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Nove lozinke, pristupni ključevi i druge informacije od sada će se pohranjivati na tu uslugu. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; može koristiti ono što je na ekranu da utvrdi šta se može automatski popuniti"</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Koristiti uslugu %1$s?"</string>
    <string name="credman_confirmation_turn_off_positive_button" msgid="5678773011513369161">"Isključi"</string>
    <string name="credman_confirmation_change_provider_positive_button" msgid="7732302992885116967">"Promijeni"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"Možete imati samo 5 uključenih usluga"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Isključite barem 1 uslugu da dodate drugu"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s koristi sadržaj na ekranu da odredi šta se može automatski popuniti."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Ograničeni broj usluga za lozinke, pristupne ključeve i podatke"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"U datom trenutku možete imati najviše 5 aktivnih usluga za lozinke, pristupne ključeve i podatke. Isključite uslugu da dodate više."</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">"Nivo zapisivanja"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maksimalni broj zahtjeva po sesiji"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maksimalni broj vidljivih kompleta podataka"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Vraćanje na zadane vrijednosti"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Opcije za programere za automatsko popunjavanje su vraćene na zadane postavke"</string>
    <string name="location_category" msgid="3496759112306219062">"Lokacija"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Pokazatelj lokacije na statusnoj traci"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Prikaz za sve lokacije, uključujući mreže i povezivost"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Prisilno omogući potpuno GNSS mjerenje"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Praćenje svih konstelacija i frekvencija GNSS-a bez ciklusa rada"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Način unosa"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Rukopis s pisaljkom"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Kada je omogućeno, trenutni način unosa prima MotionEvent pisaljke ako je uređivač fokusiran."</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema uređaja"</string>
    <string name="default_theme" msgid="4815428567082263639">"Zadano"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Naziv mreže"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Prikaz naziva mreže na statusnoj traci"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant aplikacija"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Želite li isključiti upravitelja pohranom?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Ažurirajte način rada Ne ometaj"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pauzirajte obavještenja da ostanete fokusirani"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcija nije dostupna"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Ova funkcija je isključena jer usporava vaš telefon"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Uvijek prikaži dijaloški okvir za pad aplikacije"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Prikaz dijaloškog okvira pri svakom padu aplikacije"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Odaberite aplikaciju u kojoj je omogućen ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Aplikacija u kojoj je omogućen ANGLE nije postavljena"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikacija u kojoj je omogućen ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Postavke drajvera za grafiku"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Promjena postavki drajvera za grafiku"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kada je uključeno više drajvera za grafiku možete odabrati da za aplikacije koje su instalirane na uređaju koristite ažurirani drajver za grafiku."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Omogućeno za sve aplikacije"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Odabir drajvera za grafiku"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Zadano"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Drajver za igru"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Drajver programera"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Drajver za grafiku sistema"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="enable_angle_as_system_driver" msgid="4648827560023949786">"Eksperimentalno: omogućite ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Upozorenje: omogućava ANGLE kao zadani drajver OpenGL ES-a. Ova funkcija je eksperimentalna i možda neće biti kompatibilna s određenim aplikacijama za kameru i videozapise."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Ponovno pokretanje je potrebno za promjenu sistemskog drajvera OpenGL ES"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Izmjene kompatibilnosti aplikacije"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Uključivanje/isključivanje izmjena kompatibilnosti aplikacije"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Zadano omogućene izmjene"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Zadano onemogućene izmjene"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Promjene kompatibilnosti aplikacije je moguće izmijeniti isključivo kod aplikacija kod kojih je moguće izvršiti otklanjanje grešaka. Instalirajte aplikaciju kod koje je moguće izvršiti otklanjanje grešaka i pokušajte ponovo."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Zavisi od druge postavke"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Račun"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"%d račun(a)"</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 informacije i propisi"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Detalji 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 WiFi-jem"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Dozvoli aplikaciji da upravlja WiFi-jem"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Dozvolite ovoj aplikaciji da uključuje ili isključuje WiFi, skenira i povezuje se s WiFi mrežama, dodaje ili uklanja mreže te pokreće lokalnu pristupnu tačku"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Pokretanje putem NFC-a"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Dozvoli pokretanje kada se NFC skenira"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Dozvolite aplikaciji da se pokrene kada se NFC oznaka skenira.\nAko je ovo odobrenje uključeno, aplikacija će biti dostupna kao opcija kad god se oznaka otkrije."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Reprodukcija medija na"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Reproduciraj <xliff:g id="LABEL">%s</xliff:g> na"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Zvuk će se reproducirati na uređaju"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Ovaj uređaj"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Nedostupno za vrijeme poziva"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Primanje poziva"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Ovaj APN se ne može promijeniti."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Sprečavanje zvonjenja"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Zajedno pritisnite dugme za napajanje i pojačavanje da postavite:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Prečica za sprečavanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibracija"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Isključen zvuk"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibracija"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Isključen zvuk"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Da omogućite, najprije promijenite opciju \"Pritisnite i zadržite dugme za uključivanje\" u meni napajanja."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detalji o mreži"</string>
    <string name="devices_title" msgid="649715719278562515">"Uređaji"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Odaberite mrežu"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Veza je prekinuta"</string>
    <string name="network_connected" msgid="7637745547242487795">"Povezano"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Povezivanje…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Povezivanje nije uspjelo"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nije pronađena nijedna mreža."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nisu pronađene mreže. Pokušajte ponovo."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(zabranjeno)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Nema SIM-a"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Nema"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Potreban je SIM da se povežete"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Potreban je SIM operatera <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> da se povežete"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Preferirani način rada mreže: preferiraj WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Preferirani način rada mreže: samo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Preferirani način rada mreže: samo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Preferirani način rada mreže: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Preferirani način rada mreže: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Preferirani način rada mreže: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Preferirani način rada mreže: samo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Preferirani način rada mreže: samo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Preferirani način rada mreže: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Preferirani način rada mreže: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Preferirani način rada mreže: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Preferirani način rada mreže: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Preferirani način rada mreže: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Preferirani način rada mreže: globalno"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Preferirani način rada mreže: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Preferirani način rada mreže: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Preferirani način rada mreže: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Preferirani način rada mreže: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Preferirani način rada mreže: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Preferirani način rada mreže: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Preferirani način rada mreže: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Preferirani način rada mreže: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Preferirani način rada mreže: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Preferirani način rada mreže: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Preferirani način rada mreže: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Preferirani način rada mreže: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Preferirani način rada mreže: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Preferirani način rada mreže: samo NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Preferirani način rada mreže: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Preferirani način rada mreže: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Preferirani način rada mreže: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Preferirani način rada mreže: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Preferirani način rada mreže: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Preferirani način rada mreže: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Preferirani način rada mreže: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Preferirani način rada mreže: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Preferirani način rada mreže: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Preferirani način rada mreže: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_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">"Postavke operatera"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Postavi prijenos podataka"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Pristup prijenosu podataka putem mobilne mreže"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon će se automatski prebaciti na ovog operatera kada bude u dometu"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Nije dostupan nijedan SIM"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Postavke za pozive"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Postavke za SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Pitaj svaki put"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"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 prijenos mobilnih podataka"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Prijenos mobilnih podataka je aktivan"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Prijenos mobilnih podataka je isključen"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Dostupno"</string>
    <string name="mobile_network_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">"Sačuvaj"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Koristi ovaj SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Isključeno"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="7182341033728911879">"Da isključite ovaj SIM, uklonite SIM karticu"</string>
    <string name="mobile_network_tap_to_activate" msgid="5280456487243915465">"Dodirnite da aktivirate SIM operatera <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="5387971155494245850">"Potpuno izbriši podatke na eSIM-u"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Preferirana vrsta mreže"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Promijenite način rada mreže"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Preferirana vrsta mreže"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Verzija postavki mobilnog operatera"</string>
    <string name="call_category" msgid="641461844504128789">"Pozivanje"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Video pozivi putem mobilnog operatera"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Odabir sistema"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Promijenite način rada CDMA rominga"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Odabir sistema"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Mreža"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA pretplata"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Promjena između RUIM/SIM i NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"pretplata"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatska registracija…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Dozvoliti roming podataka?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Raspitajte se kod svog mobilnog operatera za cijene."</string>
    <string name="mobile_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="satellite_setting_title" msgid="2543034229989047673">"Satelitska razmjena poruka"</string>
    <string name="satellite_setting_enabled_summary" msgid="3554127722727530845">"Šaljite i primajte poruke putem satelita. Uključeno je uz račun."</string>
    <string name="satellite_setting_disabled_summary" msgid="6789122487534159857">"Šaljite i primajte poruke putem satelita. Nije uključeno uz račun."</string>
    <string name="keywords_satellite_setting" msgid="3312183289776517695">"Satelitska razmjena poruka"</string>
    <string name="category_name_about_satellite_messaging" msgid="3756205049485508340">"O satelitskoj razmjeni poruka"</string>
    <string name="title_about_satellite_setting" msgid="9212860038048311345">"Mogućnost slanja i primanja poruka putem satelita imate u okviru računa kod operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g> koji ispunjava uslove"</string>
    <string name="category_title_your_satellite_plan" msgid="3017895097366691841">"Vaš paket kod operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="title_have_satellite_plan" msgid="2048372355699977947">"Satelitska razmjena poruka je uključena uz račun"</string>
    <string name="title_no_satellite_plan" msgid="2876056203035197505">"Satelitska razmjena poruka nije uključena uz račun"</string>
    <string name="summary_add_satellite_setting" msgid="3815254731634052432">"Dodajte satelitsku razmjenu poruka"</string>
    <string name="category_name_how_it_works" msgid="585303230539269496">"Kako funkcionira"</string>
    <string name="title_satellite_connection_guide" msgid="3294802307913609072">"Kada nemate mobilnu mrežu"</string>
    <string name="summary_satellite_connection_guide" msgid="3496123195218418456">"Telefon će se automatski povezati sa satelitom. Da veza bude najbolja, pogled na nebo ne smije biti zapriječen."</string>
    <string name="title_supported_service" msgid="4275535165812691571">"Nakon što se telefon poveže sa satelitom"</string>
    <string name="summary_supported_service" msgid="4320535903444834786">"Poruke možete slati svakome, uključujući hitne službe. Telefon će se ponovo povezati s mobilnom mrežom kada bude dostupna."</string>
    <string name="satellite_setting_summary_more_information" msgid="4008690241760925372">"Satelitska razmjena poruka može trajati duže i dostupna je samo u nekim područjima, a na satelitsku vezu mogu uticati vremenske prilike i određeni objekti. Pozivanje putem satelita nije dostupno.\n\nPrikazivanje promjena računa u Postavkama može potrajati. Za detalje kontaktirajte operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="more_about_satellite_messaging" msgid="3385673133561348509">"Više o satelitskoj razmjeni poruka"</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Nazivi pristupne tačke"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"APN"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nedostupno kada ste povezani s operaterom <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Prikaži više"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Uključiti 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">"Prebaciti na operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Prebaciti na korištenje SIM kartice?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Koristiti operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="7474905814976249607">"U svakom trenutku može biti uključen samo 1 SIM.\n\nPrebacivanjem na operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> se neće otkazati usluga operatera <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="6415848271400253954">"U svakom trenutku može biti uključen samo 1 eSIM.\n\nPrebacivanjem na operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> se neće otkazati usluga operatera <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="421658355882679837">"U svakom trenutku može biti uključen samo 1 SIM.\n\nPrebacivanjem se neće otkazati usluga operatera <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Možete istovremeno koristiti 2 SIM-a. Da koristite 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 operatera <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="8144175623622669136">"Aktiviranje SIM-a…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="697127154780501304">"Prebacivanje na operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="2718084141744769701">"Nije moguće promijeniti SIM"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="8332742656111984482">"Nešto nije uredu. Nije moguće promijeniti SIM."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Isključiti 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="1808735136395980905">"Nije moguće isključiti SIM"</string>
    <string name="privileged_action_disable_fail_text" msgid="6236231745255527458">"Nešto nije uredu. Isključivanje SIM-a nije uspjelo."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Koristiti 2 SIM-a?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Na uređaju mogu istovremeno biti aktivna dva SIM-a. Da nastavite koristiti samo jedan SIM, dodirnite \"Ne, hvala\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Ponovo pokrenuti uređaj?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Da"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Ponovo pokreni"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Ne, hvala"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Otkaži"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Prebaci"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Isključi"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Nije moguće aktivirati SIM"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Pokušajte ponovo uključiti SIM. Ako se problem ne riješi, ponovo pokrenite uređaj."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"Postavite SIM"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Postavite postavke mobilne mreže da koristite više SIM-ova na uređaju"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"Označite SIM-ove"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"Vidjet ćete ove oznake prilikom upućivanja poziva, slanja poruka i korištenja prijenosa podataka i u Postavkama"</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"Oznaka SIM-a"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Oznaka"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Odaberite SIM-ove za korištenje"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"Možete istovremeno koristiti 2 SIM-a"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Postavite primarne SIM-ove"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Odaberite SIM-ove koji će se prema zadanim postavkama koristiti za pozive, poruke i prijenos podataka"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"Primarni SIM-ovi"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Pozivi"</string>
    <string name="primary_sim_texts_title" msgid="1287584042733097749">"Poruke"</string>
    <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Autom. prebac. na prij. podataka"</string>
    <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Koristite prijenos podataka s bilo kojeg SIM-a ovisno o pokrivenosti i dostupnosti"</string>
    <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Samo prijenos podataka"</string>
    <string name="sim_onboarding_setup" msgid="5750393553605388463">"Postavi"</string>
    <string name="sim_onboarding_next" msgid="6415025179929475355">"Naprijed"</string>
    <string name="sim_onboarding_progressbar_turning_sim_on" msgid="1163318788393361574">"Uključivanje operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Mobilna mreža"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Broj telefona"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"Oznaka i boja SIM-a"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktiviranje mreže"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Promjena operatera"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="975447139749692794">"SIM operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g> je aktivan"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Dodirnite da ažurirate postavke SIM-a"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Prebacili ste se na operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Prebacili ste se na drugog mobilnog operatera"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Vaša mobilna mreža je promijenjena"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Postavite svoj drugi SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Odaberite aktivni SIM ili koristite 2 SIM-a istovremeno"</string>
    <string name="choose_sim_title" msgid="66509047151583877">"Odaberite SIM koji želite koristiti"</string>
    <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{1 SIM je dostupan na ovom uređaju, ali u svakom trenutku možete koristiti samo jedan}=2{2 SIM-a su dostupna na ovom uređaju, ali u svakom trenutku možete koristiti samo jedan}one{# SIM je dostupan na ovom uređaju, ali u svakom trenutku možete koristiti samo jedan}few{# SIM-a su dostupna na ovom uređaju, ali u svakom trenutku možete koristiti samo jedan}other{# SIM-ova je dostupno na ovom uređaju, ali u svakom trenutku možete koristiti samo jedan}}"</string>
    <string name="choose_sim_activating" msgid="6485547671356386998">"Uključivanje<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="866488735834045525">"Uključivanje SIM-a trenutno nije uspjelo"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Koristiti operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Usluge operatera <xliff:g id="CARRIER_NAME">%1$s</xliff:g> će se koristiti za prijenos podataka na mobilnoj mreži, pozive i SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nema dostupnih SIM-ova"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Da kasnije koristite prijenos podataka na mobilnoj mreži, funkcije poziva i SMS, idite u postavke mreže"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Potpuno izbrisati ovaj eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="1406141218170595272">"Ovim se uklanja usluga operatera <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> s uređaja, ali se vaš paket kod operatera <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> neće otkazati."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Potpuno izbriši"</string>
    <string name="erasing_sim" msgid="4237180547590463930">"Potpuno brisanje podataka na eSIM-u…"</string>
    <string name="erase_sim_fail_title" msgid="1445700500168357303">"Nije moguće potpuno izbrisati podatke na eSIM-u"</string>
    <string name="erase_sim_fail_text" msgid="6898841004987411547">"Nešto nije uredu i podaci na eSIM-u nisu potpuno izbrisani.\n\nPonovo pokrenite uređaj i pokušajte ponovo."</string>
    <!-- no translation found for wifi_warning_dialog_title (7328515476966592390) -->
    <skip />
    <!-- no translation found for wifi_warning_dialog_text (6584060137703953174) -->
    <skip />
    <!-- no translation found for wifi_warning_continue_button (8171574741789688214) -->
    <skip />
    <!-- no translation found for wifi_warning_return_button (6226063181583906340) -->
    <skip />
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Povezivanje s uređajem"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplikacija <xliff:g id="APPNAME">%1$s</xliff:g> želi koristiti privremenu WiFi mrežu da se poveže s vašim uređajem"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nije pronađen nijedan uređaj Provjerite jesu li uređaji uključeni i dostupni za povezivanje."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Pokušaj ponovo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Nešto se dogodilo. Ova aplikacija je otkazala zahtjev za odabir uređaja."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Uspješno povezivanje"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Veza nije uspjela"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Prikaži sve"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Traženje uređaja…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Povezivanje s uređajem…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Lijeva"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Desni"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Maska"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Ploča s postavkama"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Nametni način rada na računaru"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Nametanje eksperimentalnog načina rada na računaru na sekundarnim ekranima"</string>
    <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ćava 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 nametanje uvijek uključene tamne teme"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privatnost"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Odobrenja, aktivnost računa, lični podaci"</string>
    <string name="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 ovaj prijedlog?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Ponestaje prostora za pohranu. Iskorišteno: <xliff:g id="PERCENTAGE">%1$s</xliff:g> – Slobodno: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Pošalji povratne informacije"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Želite li nam pružiti povratne informacije o ovom prijedlogu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Sljedeći sadržaj je kopiran u međumemoriju: <xliff:g id="COPY_CONTENT">%1$s</xliff:g>"</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Korištenje pristupačnosti"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 aplikacija ima potpuni pristup vašem uređaju}one{# aplikacija ima potpuni pristup vašem uređaju}few{# aplikacije imaju potpuni pristup vašem uređaju}other{# aplikacija ima potpuni 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 prikupiti informacije o vašoj lokaciji prilikom korištenja ove usluge za hitne pozive.\n\nDetalje potražite u pravilima privatnosti mobilnog operatera."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Možete izgubiti pristup preostalom vremenu ili podacima. Prije uklanjanja, provjerite s pružaocem usluga."</string>
    <string name="content_capture" msgid="868372905432812238">"Sadržaj aplikacije"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Dozvolite aplikacijama da šalju sadržaj Android sistemu"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Snimi snimak dinamičkog dijela memorije sistema"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Ekstenz. za označavanje memorije"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Ekstenzija za označavanje memorije (Memory Tagging Extension, MTE) otkriva sigurnosne probleme memorije u aplikaciji i poboljšava sigurnost izvornog koda."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Uključivanje MTE-a može uzrokovati sporije performanse 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ćavanje MTE-a dok ga ne isključite"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Morat ćete ponovo pokrenuti uređaj da uključite MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Morat ćete ponovo pokrenuti uređaj da isključite MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Omogućavanje MTE-a za jednu sesiju"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sistem će se ponovo pokrenuti i dozvoliti eksperimentiranje s Ekstenzijom za označavanje memorije (Memory Tagging Extension, MTE). MTE može negativno uticati na performanse i stabilnost sistema. Poništit će se prilikom sljedećeg ponovnog pokretanja sistema."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Ponovo pokrenite 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">"Snimanje dinamičkog dijela memorije sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Snimak dinamičkog dijela memorije sistema nije snimljen."</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automatsko snimanje snimaka dinamičkog dijela memorije sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automatski snimi snimke dinamičkog dijela memorije za Android sistem kada koristi previše memorije"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Prekini vezu"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Hitni pozivi"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Vaš operater ne podržava hitne pozive preko funkcije Pozivanje putem WiFi-ja.\nUređaj će se automatski prebaciti na mobilnu mrežu kako bi se uspostavio hitni poziv.\nHitni pozivi su mogući samo na područjima pokrivenim mobilnom mrežom."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Korištenje WiFi-ja za pozive radi poboljšanja kvaliteta"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Dolazna MMS poruka"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Nije moguće poslati MMS poruku"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Dodirnite da dozvolite MMS poruke na mreži <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> kada je isključen prijenos podataka na mobilnoj mreži"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS poruka"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problem sa SIM kombinacijom"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Korištenje mobilnih operatera <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> možete ograničiti funkcionalnost. Dodirnite da saznate više."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM kombinacija"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informacije o radnim pravilima"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Postavkama upravlja vaš IT administrator"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Pokreni uz veličinu stranica od 16 kB"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Pokrenite uređaj s jezgrom podržanom za str. od 16 kB"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Ponovo pokrenuti s jezgrom kompatibilnom sa stranicama od 16 kB?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"UPOZORENJE: određene aplikacije možda nisu kompatibilne s ovim načinom rada. Uređaj će se ponovo pokrenuti nakon potvrde."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Ponovo pokrenuti s jezgrom kompatibilnom sa stranicama od 4 kB?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"Uređaj će se ponovo pokrenuti nakon potvrde."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Ažuriranje jezgre u jezgru kompatibilnu sa stranicama od 16 kB nije uspjelo."</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Primjena promjene"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Obrađivač izvještaja o greškama"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Određuje koja aplikacija obrađuje prečicu za Izvještaj o greškama na uređaju."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Lično"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Posao"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Sistemski zadano"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Ništa"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Ovaj odabir više nije važeći. Pokušajte ponovo."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Pritisnite i zadržite dugme za uključivanje"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Pritisnite i zadržite dugme za uključivanje da pristupite"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Meni napajanja"</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">"Pristupite digitalnom asistentu"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Pristupite meniju napajanja"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Da koristite, prvo postavite zaključavanje ekrana"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Meni napajanja:\nistovremeno pritisnite dugme za uključivanje i dugme za pojačavanje zvuka"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Spriječite zvonjenje:\nza prečicu pritisnite dugme za jačinu zvuka"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Trajanje pritiska i zadržavanja"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Podesite osjetljivost odabirom toga koliko dugo treba pritisnuti i zadržati dugme za uključ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">"Dozvolite pristup novčaniku sa zaključanog ekrana"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Prikaži skener QR koda"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Dozvolite pristup skeneru QR kôda sa zaključanog ekrana"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Prikaži kontrole uređaja"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Sa zaključanog ekrana"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Koristi kontrole uređaja"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Da koristite, najprije uključite \"Prikaži kontrole uređaja\""</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Veličina sata se mijenja u skladu sa sadržajem na zaključanom ekranu"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dinamični sat"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Prečice"</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 isključujete i 5G vezu.\nTokom glasovnog poziva ne možete koristiti internet i neke aplikacije možda neće raditi."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Obustava izvršenja za keširane aplikacije"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Ne ističe nikada."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Najam ne ističe nikada."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Dozvoli preklapanja ekrana u Postavkama"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Dozvolite aplikacijama koje mogu prikazivati preko drugih aplikacija da preklapaju ekrane Postavki"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Dozvoli Mock Modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Dozvolite ovom uređaju da pokrene uslugu Mock Modem za instrumentacijsko testiranje. Nemojte to omogućavati za vrijeme normalnog korištenja telefona"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications" msgid="4987116103699222633">"Onemogući zaštite tokom dijeljenja ekrana"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary" msgid="932295234626582052">"Onemogućava zaštite aplikacija i obavještenja koje sistem primjenjuje tokom dijeljenja ekrana"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Mediji"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Zakači plejer medija"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Za brzo nastavljanje reprodukcije plejer medija ostaje otvoren u Brzim postavkama"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Prikazuj medije na zaključanom ekranu"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Za brzo nastavljanje reprodukcije plejer medija ostaje otvoren na zaključanom ekranu"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Prikaži preporuke medija od Asistenta"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Na osnovu vaše aktivnosti"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Sakrij plejer"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Prikaži plejer"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"mediji"</string>
    <string name="camera_extensions_fallback_title" msgid="3604579046777004989">"Dozvoli softverske ekstenzije kamere"</string>
    <string name="camera_extensions_fallback_description" msgid="6939818294458854536">"Omogućava zadanu softversku primjenu naprednih funkcija kamere kao što je videografija za slijepe i slabovidne."</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">"Pozivanje putem WiFi-ja"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Uspostavljajte i primajte pozive putem WiFi mreže"</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"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nedostupno"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Trenutno nije dostupno"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Nema SIM-a"</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čni, podaci, wifi, wi-fi, wi fi, celularni, mobilni, mobilni operater, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Vratiti internetsku vezu na zadano?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Vraćanje internetske veze na zadano…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Popravi povezivost"</string>
    <string name="networks_available" msgid="3299512933684383474">"Mreže su dostupne"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Da promijenite mrežu, isključite ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ veze"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Dozvolite da Google Fi koristi W+ mreže da poboljšate brzinu i pokrivenost"</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="3077009911935592178">"Uključeno"</string>
    <string name="sim_category_inactive_sim" msgid="7351553344148400450">"Isključeno"</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">"pozivi"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"prijenos podataka na mobilnoj mreži"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Radi poboljšanja iskustva s uređajem aplikacije i usluge i dalje mogu u bilo kojem trenutku skenirati WiFi mreže, čak i kada je WiFi isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji. Ovo možete promijeniti u postavkama Skeniranja WiFi mreže."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Izmijenite"</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 se koristi <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Niste povezani s mrežom"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Prijenos podataka se neće automatski povezati"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Isključiti prijenos podataka na mobilnoj mreži?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Nećete imati pristup podacima ili internetu putem mobilnog operatera <xliff:g id="CARRIER">%s</xliff:g>. Internet će biti dostupan samo putem WiFi-ja."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"vaš mobilni operater"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Ne dozvoljava vaša organizacija"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nije dostupno jer je uključen način rada za spavanje"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Poništavanje važnosti obavještenja je završeno."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikacije"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Uređaj želi pristupiti vašim porukama. Dodirnite za detalje."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Dozvoliti pristup porukama?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Bluetooth uređaj, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, želi pristupiti vašim porukama.\n\nNiste se prije povezivali s uređajem <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Uređaj želi pristupiti vašim kontaktima i zapisniku poziva. Dodirnite za detalje."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Dozvoliti pristup kontaktima i zapisniku poziva?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Bluetooth uređaj, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, želi pristupiti vašim kontaktima i zapisniku poziva. To obuhvata podatke o dolaznim i odlaznim pozivima.\n\nNiste se prije povezivali s uređajem <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Osvjetljenje"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Zaključavanje ekrana"</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 ekrana"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Opće"</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">"Koristi sprečavanje zvonjenja"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Koristi WiFi pristupnu tačku"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Koristi kačenje aplikacije"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Koristi opcije za programere"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Koristi uslugu štampanja"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Dozvoli više korisnika"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"dozvoliti, višestruko, korisnik, dopustiti, mnogo"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Koristi bežično otklanjanje grešaka"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Koristi postavke drajvera 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 osvijetljenost"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Koristi pozivanje putem WiFi-ja"</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 je omogućeno"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Pametno prosljeđivanje je 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">"Greška u postavkama poziva"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Greška na mreži ili SIM-u."</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 brojeve telefona"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Unesite broj telefona"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Broj telefona nedostaje."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"Uredu"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Dozvoli 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G mreža je manje sigurna, ali može poboljšati vezu na nekim lokacijama. Za hitne pozive 2G mreža je uvijek dozvoljena."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> zahtijeva da 2G mreža bude dostupna"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Zatražite šifriranje"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Šifriranje je mnogo sigurnije, ali moguće je da se nećete moći povezati na nekim lokacijama. Za hitne pozive šifriranje nikada nije potrebno."</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đumemoriji"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Vidite poruku kada aplikacije pristupe tekstu, slikama ili drugom sadržaju koji ste kopirali"</string>
    <string name="all_apps" msgid="3054120149509114789">"Sve aplikacije"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Nemoj dozvoliti"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra široki opseg"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomoć pri određivanju relativnog položaja uređaja u blizini koji imaju ultra široki opseg"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Isključite način rada u avionu da koristite UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Ultra široki opseg nije dostupan na trenutnoj lokaciji"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Pristup kameri"</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 ova postavka isključena, podaci mikrofona se i dalje mogu dijeliti kada pozovete broj za hitne slučajeve."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Nazad"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Naprijed"</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 za detalje."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Dozvoliti 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 obuhvata vaše kontakte.\n\nDok je povezan, uređaj <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> će primati sve pozive upućene na broj <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Bluetooth uređaj je dostupan"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Uređaj se želi povezati. Dodirnite za detalje."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Povezati se s Bluetooth uređajem?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"Uređaj <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> se želi povezati s ovim telefonom.\n\nRanije 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 se povezati"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Poveži"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Postavke za TARE"</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">"Vrati 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">"Stanje maksimalnog zasićenja"</string>
    <string name="tare_balances" msgid="731881382594747961">"Stanje računa"</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 (cijena izrade)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Radnje (osnovna cijena)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Nagrade po jednom događaju"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Nagrade po sekundi trajanja događaja"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maksimalni broj nagrada po danu"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Instaliranje aplikacije"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Maksimalna aktivnost"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Obavještenje je viđeno"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Obavještenje je viđeno u roku od 15 minuta"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interakcija s obavještenjima"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interakcija s vidžetom"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Interakcija s drugim korisnikom"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Pokretanje zadatka maksimalnog prioriteta"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Pokrenut je zadatak maksimalnog prioriteta"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Pokretanje zadatka visokog prioriteta"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Pokrenut je 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">"Pokrenut je 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">"Pokrenut je zadatak niskog prioriteta"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Pokretanje zadatka minimalnog prioriteta"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Pokrenut je zadatak minimalnog prioriteta"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Kazna za istek vremena zadatka"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimalno stanje kada je uređaj napunjen (Izuzetak)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimalno stanje kada je uređaj napunjen (Sistemska aplikacija bez interfejsa)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimalno stanje kada je uređaj pun (Preostale aplikacije)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Dodavanje minimalnog stanja kada je uređaj pun (alati za ažuriranje aplikacija)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Punjenje"</item>
    <item msgid="658627268149681677">"Doziranje"</item>
    <item msgid="1599558140284643834">"Način rada uštede 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">"Pregledajte"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Odaberite čuvar ekrana"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Prikaži dodatne informacije"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Prikaz stvari kao što su vrijeme, vremenska prognoza ili druge informacije na čuvaru ekrana"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Prikaži kontrole za dom"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Prikaz dugmeta kontrola za dom s čuvara ekrana"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Više postavki"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Odaberite čuvar ekrana"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Odaberite šta će se prikazivati na ekranu kada je tablet na priključnoj stanici. Uređaj može trošiti više energije kada se koristi čuvar ekrana."</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">"Potrebno je ponovno pokretanje da se omogući podrška za slobodni oblik."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Potrebno je ponovno pokretanje da se nametne način rada računara na sekundarnim ekranima."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Ponovo pokreni sada"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Ponovo 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 iz kompatibilnih medija postaje prostraniji"</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 dok pomjerate glavu radi prirodnijeg zvuka"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Sinhronizirajte odobrenja s telefona"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Na satu dodijelite ista odobrenja za aplikaciju koja ste dozvolili na ovom telefonu"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Vrsta audio uređaja"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Nepoznato"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Zvučnik"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Slušalice"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Slušni aparat"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Komplet za automobil"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Drugo"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Ograničenje stope preuzimanja mreže"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfigurirajte ograničenje stope ulaza 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">"Konfigurirajte ograničenje stope preuzimanja mreže"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Nema ograničenja"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Onemogući ograničenja podređenog procesa"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Onemogućite ograničenja u korištenju resursa sistema za podređene procese aplikacije"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Prisilno omogući ulogu Bilješke"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Omogućite integracije sistema za pisanje bilješki putem uloge Bilješke. Ako je uloga Bilješke već omogućena, neće se ništa dogoditi. Potrebno je ponovno pokretanje."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Emitirajte"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Emitiraj aplikaciju <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 vašoj blizini"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Emitirajte medije na uređaje u blizini ili slušajte emitiranja druge osobe"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Emitiranja"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Slušate"</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 lozinku"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Nije se moguće povezati. Pokušajte ponovo."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Pogrešna lozinka"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Nije se moguće pridružiti emitiranju"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Da pokrenete slušanje, centrirajte QR kôd ispod"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Format QR koda nije važeći"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Pretvori 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č uređaja može u pozadini instalirati aplikacije na vaš uređaj ili dozvoliti operateru i drugim partnerima da to rade.\n\nNijedna aplikacija navedena ovdje nije obavezna za normalno funkcioniranje uređaja. Možete deinstalirati aplikacije koje ne želite."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Nijedna aplikacija nije instalirana 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 proteklom mjesecu}one{Aplikacije instalirane u proteklom # mjesecu}few{Aplikacije instalirane u protekla # mjeseca}other{Aplikacije instalirane u proteklih # mjeseci}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplikacije instalirane prije # mjesec}one{Aplikacije instalirane prije # mjesec}few{Aplikacije instalirane prije # mjeseca}other{Aplikacije instalirane prije # mjeseci}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Format slike"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Isprobajte novi format slike u kojem će se aplikacija prikazivati ako nije dizajnirana da odgovara uređaju <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Isprobajte novi format slike u kojem će se aplikacija prikazivati ako nije dizajnirana da odgovara uređaju <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Neke aplikacije se možda neće optimizirati za određene formate slike."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Isprobajte novi format slike u kojem će se aplikacija prikazivati ako nije dizajnirana da odgovara uređaju <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Isprobajte novi format slike u kojem će se aplikacija prikazivati ako nije dizajnirana da odgovara uređaju <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Neke aplikacije se možda neće optimizirati za određene formate slike."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Predložene aplikacije"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Promijenjene aplikacije"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Zadano za aplikaciju"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Prikaz preko cijelog ekrana"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Pola ekrana"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Format slike uređaja"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g>:<xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Aplikacija će se ponovo pokrenuti kada promijenite format slike. Možda ćete izgubiti nesačuvane promjene. Neke aplikacije se možda neće optimizirati za određene formate slike."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Format slike (eksperimentalno)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Format slike (eksperiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Format slike (laboratoriji)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Eksperimentalno"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Eksperiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Laboratoriji"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Senzor za otisak prsta"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Obavještenja blicanjem"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Informacije o obavještenjima blicanjem"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Isključeno"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Uključeno / blicanje kamere"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Uključeno / blicanje ekrana"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Uključeno / blicanje kamere i ekrana"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Kamera ili ekran blicaju kada primite obavještenja ili se alarmi oglase"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Ekran blica kada primite obavještenja ili se alarmi oglase"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Oprezno koristite obavještenja blicanjem ako ste osjetljivi na svjetlost"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"blicanje, svjetlo, oštećenje sluha, gubitak sluha"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Pregled"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Blicanje kamere"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Blicanje ekrana"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Boja blicanja ekrana"</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">"Biljna zelena"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Žuta"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Narandžasta"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Crvena"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Ružičasta"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</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">"Otkaži"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standardno"</string>
    <!-- no translation found for contrast_default (8918545965525226966) -->
    <skip />
    <string name="contrast_medium" msgid="384414510709285811">"Srednje"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Visoko"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ova aplikacija se može otvoriti samo u 1 prozoru"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Uključeno"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Isključeno"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Isključeno"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Isključeno"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Uključeno"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Isključeno"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Uključeno"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Isključeno"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Mijenja svijetle ekrane u tamne i tamne ekrane u svijetle"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Uvećajte na ekranu"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Isključeno"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Isključeno"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Uključeno"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Isključeno"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Uključeno"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Naziv uređaja je vidljiv aplikacijama koje ste instalirali. Također će ga moći vidjeti druge osobe prilikom povezivanja s Bluetooth uređajima i WiFi mrežom ili postavljanja WiFi pristupne tačke."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Gramatički rod"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Odaberite gramatički rod"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Skeniranje obmanjujućih aplikacija"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Provjerite aktivnost aplikacije radi otkrivanja krađe identiteta"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Koristi skeniranje obmanjujućih aplikacija"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Koristi skeniranje obmanjujućih aplikacija za posao"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
    <string name="accessibility_setup_password_complete" msgid="6358749253318369077">"Lozinka je sada postavljena"</string>
    <string name="show_stylus_pointer_icon" msgid="1010583689203665786">"Prikaži pokazivač prilikom postavljanja pokazivača miša iznad stavke"</string>
</resources>
