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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Da"</string>
    <string name="no" msgid="6731231425810196216">"Ne"</string>
    <string name="create" msgid="3578857613172647409">"Izradi"</string>
    <string name="allow" msgid="3349662621170855910">"Dopusti"</string>
    <string name="deny" msgid="6947806159746484865">"Odbij"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Nepoznato"</string>
  <plurals name="show_dev_countdown">
    <item quantity="one" msgid="5295687242294085452">"Još <xliff:g id="STEP_COUNT">%1$d</xliff:g> korak i postat ćete razvojni programer."</item>
    <item quantity="other" msgid="6722953419953594148">"Još <xliff:g id="STEP_COUNT">%1$d</xliff:g> koraka i postat ćete razvojni programer ."</item>
  </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Sad ste razvojni programer!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nema potrebe, već ste razvojni programer."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Bežično povezivanje i mreže"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Veze"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Uređaj"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Osobno"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Pristup"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sustav"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Uključi radio"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Isključi radio"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Uključi SMS putem IMS-a"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Isključi SMS putem IMS-a"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Treba uključiti IMS prijavu"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Treba isključiti IMS prijavu"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Uključi LTE RAM kopiranje"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Isključi LTE RAM kopiranje"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Prikaži SIM imenik"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Prikaži brojeve za fiksno biranje"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Prikaži brojeve za servisno biranje"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Dohvati PDP popis"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"Koristi se"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Ne radi"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Samo hitni pozivi"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Radio je isključen"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Bez roaminga"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"U mirovanju"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Zvono"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Poziv u tijeku"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Niste povezani"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Povezivanje"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Povezan"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Obustavljeno"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"nepoznato"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pkts"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajtovi"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Isključi USB memoriju"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Isključi SD karticu"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Izbriši memoriju USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Izbriši karticu SD"</string>
    <string name="small_font" msgid="2295331917424072635">"Mali"</string>
    <string name="medium_font" msgid="2068475425515133701">"Srednji"</string>
    <string name="large_font" msgid="599055175160971446">"Veliki"</string>
    <string name="font_size_save" msgid="3450855718056759095">"U redu"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Memorija USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"SD kartica"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"Status baterije:"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Priključivanje napajanja:"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Baterijska skala:"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Razina baterije:"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"Zdravlje baterije:"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Tehnologija baterije:"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Napon baterije:"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Temperatura baterije:"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"°C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Vrijeme proteklo od pokretanja:"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Vrijeme buđenja na bateriji:"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Vrijeme buđenja kod punjenja:"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Zaslonsko vrijeme uključenosti:"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Nepoznato"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Punjenje"</string>
    <string name="battery_info_status_charging_ac" msgid="2909861890674399949">"Punjenje punjačem"</string>
    <string name="battery_info_status_charging_usb" msgid="2207489369680923929">"Punjenje putem USB-a"</string>
    <string name="battery_info_status_charging_wireless" msgid="3574032603735446573">"Bežično punjenje"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Ne puni se"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Ne puni se"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Puna"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Neuključeno"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"AC"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_wireless" msgid="6819163295739305097">"bežično povezivanje"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"AC+USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Nepoznato"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Nepoznato"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Dobro"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Pregrijano"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Ne reagira"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Prejaki napon"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Nepoznata pogreška"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Hladno"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Vidljivo svim Bluetooth uređajima u blizini (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Vidljivo svim Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Nije vidljiv drugim Bluetooth uređajima"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Vidljivo samo uparenim uređajima"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Vidljivost je istekla"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Zaključaj biranje glasom"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Spriječite upotrebu Bluetooth birača ako je zaslon zaključan"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Bluetooth uređaji"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Naziv uređaja"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Postavke uređaja"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Postavke profila"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Bez postavke imena, koristi naziv računa"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Skeniranjem traži uređaje"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Preimenuj ovaj uređaj"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Preimenuj"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Isključiti?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"To će prekinuti vašu vezu s uređajem:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="1185354873716211496">"Nemate dopuštenje za promjenu postavki Bluetootha."</string>
    <!-- no translation found for bluetooth_is_visible_message (3956514990287788968) -->
    <skip />
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Želite li prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Emitiranje"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Onemogućiti profil?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"To će onemogućiti:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;na uređaju:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_connected" msgid="6038755206916626419">"Povezan"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Povezano (bez telefona)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Povezano (bez medija)"</string>
    <string name="bluetooth_connected_no_map" msgid="6504436917057479986">"Povezano (bez pristupa porukama)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Povezano (bez telefona ili medija)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Niste povezani"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Isključivanje…"</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Povezivanje…"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Uparivanje…"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Neimenovani Bluetooth uređaj"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Pretraživanje"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"U blizini nema Bluetooth uređaja."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Zahtjev za Bluetooth uparivanje"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Zahtjev za uparivanje"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Dodirnite za uparivanje s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Prikaži primljene datoteke"</string>
    <string name="device_picker" msgid="8398232791303186677">"Birač Bluetooth uređaja"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Zatraženo je Bluetooth dopuštenje"</string>
    <string name="bluetooth_ask_enablement" msgid="637355677176904990">"Aplikacija želi uključiti Bluetooth."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Aplikacija želi vaše tabletno računalo učiniti vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Aplikacija želi vaš telefon učiniti vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Aplikacija želi učiniti vaše tabletno računalo vidljivim drugim Bluetooth uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Aplikacija želi učiniti vaš telefon vidljivim drugim Bluetooth uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_start_broadcast" product="default" msgid="3535628155254187911">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth emitiranje radi komunikacije s ostalim uređajima u blizini. To možete promijeniti kasnije u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default" msgid="8810858601242763295">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth i Bluetooth emitiranje radi komunikacije s ostalim uređajima u blizini. To možete promijeniti kasnije u postavkama Bluetootha."</string>
    <string name="bluetooth_broadcasting_explaination" product="default" msgid="4249322115655011799">"Kada je ta značajka uključena, vaš telefon može komunicirati s ostalim uređajima u blizini.\n\nEmitiranje se koristi Bluetooth signalima male snage."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Aplikacija želi uključiti Bluetooth i vaše tabletno računalo učiniti vidljivim drugim uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Aplikacija želi uključiti Bluetooth i vaš telefon učiniti vidljivim drugim uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Aplikacija želi uključiti Bluetooth i vaše tabletno računalo učiniti vidljivim drugim uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Aplikacija želi uključiti Bluetooth i vaš telefon učiniti vidljivim drugim uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Uključivanje Bluetootha…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Isključivanje Bluetootha?"</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Automatsko povezivanje"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Zatražena je Bluetooth veza"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Dodirnite za povezivanje s uređajem \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Želite li se povezati s uređajem \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Zahtjev za pristup telefonskom imeniku"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"Korisnik %1$s želio bi pristupiti vašim kontaktima i povijesti poziva. Dati pristup korisniku %2$s?"</string>
    <string name="bluetooth_remember_choice" msgid="6198284561603824931">"Više me ne pitaj"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Više me ne pitaj"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Zahtjev za pristup porukama"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s želi pristupiti vašim porukama. Želite li dati pristup korisniku %2$s?"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Datum i vrijeme"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Odabir vremenske zone"</string>
    <string name="normal_date_format" msgid="7636406984925498359">"Regionalno (<xliff:g id="DATE">%s</xliff:g>)"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Pregled:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Veličina fonta:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Pošalji <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Pokreni <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Račun:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Očisti"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Priključak proxy poslužitelja"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Zaobiđi proxy za"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com,mycomp.test.com,localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Vrati zadano"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Gotovo"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Naziv hosta proxy poslužitelja"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Pažnja"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"U redu"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Naziv hosta koji ste upisali nije valjan."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"Popis za isključivanje koji ste napisali nije pravilno formatiran. Unesite popis isključenih domena odvojenih zarezima."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Morate dovršiti polje priključka."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Polje priključka mora biti prazno ako je i polje hosta prazno."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Upisani priključak nije valjan."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Preglednik upotrebljava HTTP proxy poslužitelj, ali druge aplikacije ne mogu ga upotrebljavati."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL za PAC: "</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Lokacija:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"Susjedski CID:"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"Informacije o ćeliji:"</string>
    <string name="radio_info_dcrtinfo_label" msgid="6802395441317448068">"Informacije o DcRt:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Pokušaji za podatke:"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"GPRS usluga:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Preusmjeravanje poziva:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"Broj PPP poništavanja od pokretanja:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"GSM se isključuje:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Trenutačna mreža:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Podatkovni uspjesi:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"Primljeni PPP:"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"GSM usluga:"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Jakost signala:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Status poziva:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"PPP poslan:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Poništavanje radija:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Poruka na čekanju:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Telefonski broj:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Odaberite radijsku frekvenciju"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Vrsta mreže:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Postavite željenu vrstu mreže:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Ping IpAddr:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Ping naziv hosta (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"HTTP klijentski test:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Pokreni ping test"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Ažuriraj"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Osvježi"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Sažmi DNS provjeru"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informacije/postavke koje se posebno odnose na OEM"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Postavi mrežu GSM/UMTS"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Učitavanje popisa mrežnih postavki..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Postavi"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Neuspješno"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Uspješno"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Promijene stupaju na snagu kod ponovnog priključivanja USB kabela."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Omogući USB masovno pohranjivanje"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Ukupno bajtova:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"USB memorija nije uključena."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Nema SD kartice"</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Dostupni bajtovi"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB pohrana upotrebljava se kao uređaj masovne pohrane."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"SD kartica upotrebljava se kao uređaj za masovnu pohranu."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"Sad na siguran način možete ukloniti USB pohranu."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"Sad na siguran način možete ukloniti SD karticu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB memorija uklonjena je dok se upotrebljavala!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"SD kartica je uklonjena tijekom upotrebe!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Iskorišteni bajtovi:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Skeniranje USB mem. za medije…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Pretraživanje medija na SD kartici skeniranjem…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"USB memorija uključena samo za čitanje."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"SD kartica uključena je u načinu samo za čitanje."</string>
    <string name="skip_label" msgid="47510779345218297">"Preskoči"</string>
    <string name="next_label" msgid="4693520878012668114">"Dalje"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Jezik"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Odabir aktivnosti"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacije o uređaju"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Informacije o bateriji"</string>
    <string name="display_label" msgid="8074070940506840792">"Zaslon"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informacije o tabletnom uređaju"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacije o telefonu"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Memorija USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"SD kartica"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Proxy postavke"</string>
    <string name="cancel" msgid="6859253417269739139">"Odustani"</string>
    <string name="cancel_all_caps" msgid="3183966387632229461">"ODUSTANI"</string>
    <string name="continue_all_caps" msgid="5152713914673789893">"NASTAVI"</string>
    <string name="okay" msgid="1997666393121016642">"U redu"</string>
    <string name="yes_all_caps" msgid="5454685069075197457">"DA"</string>
    <string name="no_all_caps" msgid="3242375449351298529">"NE"</string>
    <string name="forget" msgid="7267115980248732932">"ZABORAVI"</string>
    <string name="settings_label" msgid="1626402585530130914">"Postavke"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Postavke"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Prečac postavki"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Način rada u zrakoplovu"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Više"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bežično povezivanje i mreže"</string>
    <string name="radio_controls_summary" msgid="2837395036275123133">"Upravljanje Wi-Fi-jem, Bluetoothom, načinom rada u zrakoplovu, mobilnim mrežama i VPN-ovima"</string>
    <string name="cellular_data_title" msgid="2525947635539415202">"Mobilni podaci"</string>
    <string name="calls_title" msgid="3544471959217176768">"Pozivi"</string>
    <string name="sms_messages_title" msgid="3188611825992624879">"SMS poruke"</string>
    <string name="cellular_data_summary" msgid="4575500999626276446">"Dopusti mobilni prijenos podataka"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Podatkovni promet u roamingu"</string>
    <string name="roaming" msgid="3596055926335478572">"Roaming podataka"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Poveži se s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Poveži se s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Izgubili ste podatkovnu vezu jer ste isključili mrežni roaming podataka."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Uključi"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Ako omogućite roaming podataka, može doći do značajnih troškova roaminga!"</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Kada dopustite podatkovni roaming, mogu nastati značajni troškovi roaminga!\n\nOva postavka utječe na sve korisnike na ovom tabletu."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Kada dopustite podatkovni roaming, mogu nastati značajni troškovi roaminga!\n\nOva postavka utječe na sve korisnike na ovom telefonu."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Dopusti roaming podataka?"</string>
    <string name="networks" msgid="6333316876545927039">"Odabir operatora"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Odaberite mrežnog operatera"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Datum i vrijeme"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Postavite datum i vrijeme"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Postavljanje datuma, vremena, vremenske zone i formata"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Automatski datum &amp; vrijeme"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Upotrijebi vrijeme mreže"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Upotrijebi vrijeme mreže"</string>
    <string name="zone_auto" msgid="334783869352026648">"Automatska vremenska zona"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Upotrijebi vremensku zonu mreže"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Upotrijebi vremensku zonu mreže"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24-satni oblik"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Koristi 24-satni format"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Vrijeme"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Postavi vrijeme"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Vremenska zona"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Odaberi vremensku zonu"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Datum"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Postavi datum"</string>
    <string name="date_time_date_format_title" msgid="3976171711988766411">"Oblik datuma"</string>
    <string name="date_time_date_format" msgid="6951498879879281102">"Odaberite format datuma"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Poredaj abecedno"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Poredaj po vremenskoj zoni"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Datum"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Vrijeme"</string>
    <string name="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Poboljšanje podudaranja lica"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Provjera živosti"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Prilikom otključavanja potrebno je trepnuti"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Automatsko zaključavanje"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon mirovanja"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon mirovanja, osim kad ga <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> drži oključanim"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Prikaži vlasniku informacije o zaključanom zaslonu"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Info o vlasniku"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Omogući widgete"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Onemogućio administrator"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Unesite tekst za prikaz na zaključanom zaslonu"</string>
    <string name="show_user_info_on_lockscreen_label" msgid="8408914624925608365">"Prikaži podatke o korisniku na zaključanom zaslonu"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Podaci o korisniku"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Prikaži informacije profila na zaključanom zaslonu"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Informacije profila"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Računi"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Lokacija"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Računi"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Sigurnost"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Postavi Moju lokaciju, otključavanje zaslona, zaključavanje SIM kartice, zaključavanje spremnika za vjerodajnice"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Postavi Moju lokaciju, otključavanje zaslona, zaključavanje pohranjivanja vjerodajnica"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Zaporke"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Enkripcija"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Kriptiraj tablet računalo"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Kriptiraj telefon"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Kriptirano"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="7966195172468864148">"Možete kriptirati svoje račune, postavke, preuzete aplikacije i njihove podatke, medijske i ostale datoteke. Nakon kriptiranja tableta, ako ste postavili zaključavanje zaslona (uzorak, brojčani PIN ili zaporku), morat ćete otključati zaslon da biste dekriptirali tablet svaki put kada ga uključite. Jedini je drugi način dekriptiranja vraćanje na tvorničko stanje, čime se brišu svi podaci.\n\nKriptiranje traje sat vremena ili dulje. Morate početi s napunjenom baterijom i tablet cijelo vrijeme mora biti priključen na napajanje. Ako prekinete postupak, izgubit ćete neke ili sve podatke."</string>
    <string name="crypt_keeper_desc" product="default" msgid="9182896617884899822">"Možete kriptirati svoje račune, postavke, preuzete aplikacije i njihove podatke, medijske i ostale datoteke. Nakon kriptiranja telefona, ako ste postavili zaključavanje zaslona (uzorak, brojčani PIN ili zaporku), morat ćete otključati zaslon da biste dekriptirali telefon svaki put kada ga uključite. Jedini je drugi način dekriptiranja vraćanje na tvorničko stanje, čime se brišu svi podaci.\n\nKriptiranje traje sat vremena ili dulje. Morate početi s napunjenom baterijom i telefon cijelo vrijeme mora biti priključen na napajanje. Ako prekinete postupak, izgubit ćete neke ili sve podatke."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Kriptiraj tablet uređaj"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Kriptiraj telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Napunite bateriju i pokušajte ponovo."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Uključite punjač i pokušajte ponovo."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Nema PIN-a ili zaporke za zaključani zaslon"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Prije nego što ćete moći započeti enkripciju morat ćete postaviti PIN za zaključavanje zaslona ili zaporku."</string>
    <string name="crypt_keeper_confirm_encrypt" msgid="736289627726831055">"Morate nacrtati uzorak za otključavanje da biste potvrdili kriptiranje uređaja."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Kriptirati?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Operacija kriptiranja nepovratna je i izgubit ćete podatke ako je prekinete. Kriptiranje traje sat vremena ili dulje, a za to vrijeme tabletno računalo nekoliko će se puta ponovo pokrenuti."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="5682944380460921880">"Operacija kriptiranja nepovratna je i izgubit ćete podatke ako ju prekinete. Kriptiranje traje sat vremena ili dulje, a za to vrijeme telefon će se nekoliko puta ponovo pokrenuti."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Kriptiranje"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Pričekajte dok ne završi kriptiranje vašeg tabletnog računala. <xliff:g id="PERCENT">^1</xliff:g>% dovršeno."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Pričekajte dok ne završi kriptiranje telefona. <xliff:g id="PERCENT">^1</xliff:g>% dovršeno."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Pričekajte dok se vaš tablet kodira. Preostalo vrijeme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Pričekajte dok se vaš telefon kodira. Preostalo vrijeme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_cooldown" msgid="685210918307862395">"Pokušajte ponovo za <xliff:g id="DELAY">^1</xliff:g> s."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Upozorenje: možete pokušati otključati uređaj još <xliff:g id="COUNT">^1</xliff:g> puta. Ako ne uspijete, izbrisat će se podaci na uređaju!"</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Unesite svoju zaporku"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Enkripcija neuspješna"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Enkripcija je prekinuta i ne može se dovršiti. Podaci na vašem tabletnom računali zbog toga više nisu dostupni.\n\nDa biste nastavili upotrebljavati svoje tabletno računalo, trebate provesti vraćanje u tvorničko stanje. Prilikom postavljanja tabletnog računala nakon vraćanja u tvorničko stanje imat ćete priliku vratiti sve podatke za koje ste na Google računu izradili sigurnosnu kopiju."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3083477162766772532">"Enkripcija je prekinuta i ne može se dovršiti. Stoga podaci na vašem telefonu više nisu dostupni. \n\nDa biste nastavili upotrebljavati ​​telefon, morate vratiti tvorničke postavke. Kada nakon toga postavite svoj telefon, imat ćete priliku vratiti sve podatke čije su sigurnosne kopije stvorene na vašem Google računu."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dešifriranje nije uspjelo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="3775740783651700375">"Unijeli ste točnu zaporku, ali su vaši podaci nažalost oštećeni. \n\nZa daljnju upotrebu tableta morate ga vratiti na tvorničke postavke. Nakon što vratite tablet na zadano, imat ćete priliku oporaviti podatke koje ste sigurnosno kopirali na svoj Google račun."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="6898436151871328007">"Unijeli ste točnu zaporku, ali su vaši podaci nažalost oštećeni. \n\nZa daljnju upotrebu telefona morate ga vratiti na tvorničke postavke. Nakon što vratite telefon na zadano, imat ćete priliku oporaviti podatke koje ste sigurnosno kopirali na svoj Google račun."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Promjena načina unosa"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Odaberite zaključavanje zaslona"</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Odabir sig. zaključ."</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zaključavanje zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Promjena zaklj. zasl."</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Promijenite ili onemogućite sigurnosni uzorak, PIN ili zaporku"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Odaberite metodu za zaključavanje zaslona"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Kada vas Otključavanje licem ne može vidjeti, kako želite otključati?"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Ništa"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Prelazak prstom"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Nema zaštite"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Otključavanje licem"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Niska sigurnost, eksperimentalno"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Uzorak"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Srednja razina sigurnosti"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Srednja do visoka sigurnost"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Zaporka"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Visoka sigurnost"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Onemogućili administrator, pravila enkripcije ili pohrana vjerodajnica"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Ništa"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Prelazak prstom"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Otključavanje licem"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Uzorak"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Zaporka"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Isključi zaključavanje zaslona"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Ukloni uzorak za otključavanje"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Ukloni otključavanje PIN-a"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Ukloni zaporku za zaključavanje"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Izmijeni uzorak za otključavanje"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Promijeni PIN za otključavanje"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Promijeni zaporku za otključavanje"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Zaporka mora imati najmanje ovoliko znakova: %d"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"PIN mora imati najmanje ovoliko znakova: %d"</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Dodirnite Nastavak kad završite"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Nastavi"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Zaporka mora imati manje od ovoliko znakova: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"PIN mora imati manje od ovoliko znamenki: <xliff:g id="NUMBER">%d</xliff:g>"</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"PIN mora sadržavati samo znamenke od 0 do 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"Administrator uređaja ne dopušta upotrebu nedavnog PIN-a."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Zaporka sadrži nedopušteni znak."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Zaporka treba sadržavati barem jedno slovo."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Zaporka mora sadržavati barem jednu znamenku."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Zaporka treba sadržavati barem jedan simbol."</string>
  <plurals name="lockpassword_password_requires_letters">
    <item quantity="one" msgid="3063853802158131458">"Zaporka mora sadržavati barem jedno slovo."</item>
    <item quantity="other" msgid="8186027808415585970">"Zaporka mora sadržavati barem ovoliko slova: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Zaporka mora sadržavati barem jedno malo slovo."</item>
    <item quantity="other" msgid="2693910942679679225">"Zaporka mora sadržavati barem ovoliko malih slova: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Zaporka mora sadržavati barem jedno veliko slovo."</item>
    <item quantity="other" msgid="3030801209112209245">"Zaporka mora sadržavati barem ovoliko velikih slova: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Zaporka mora sadržavati barem jednu brojčanu znamenku."</item>
    <item quantity="other" msgid="4703982391407595924">"Zaporka mora sadržavati barem ovoliko brojčanih znamenki: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Zaporka mora sadržavati barem jedan posebni simbol."</item>
    <item quantity="other" msgid="1221290525051187757">"Zaporka mora sadržavati barem ovoliko posebnih znakova: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Zaporka mora sadržavati barem jedan znak koji nije slovo."</item>
    <item quantity="other" msgid="3952508584649046404">"Zaporka mora sadržavati barem ovoliko znakova koji nisu slova: %d."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Administrator uređaja ne dopušta upotrebu nedavne zaporke."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="6830610582179569631">"Uzastopno rastući ili padajući slijed brojeva ili ponavljanje brojeva nije dopušteno"</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"U redu"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Odustani"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Odustani"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Dalje"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Postavljanje je završeno."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Administracija uređaja"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Administratori uređaja"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Administratori za prikaz ili deaktivaciju uređaja"</string>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Pouzdani predstavnici"</string>
    <string name="manage_trust_agents_summary" msgid="6804319935640148441">"Prikaz ili deaktivacija pouzdanih predstavnika"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Uključi Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Upravljajte vezama, postavite uređaj i mogućnost otkrivanja"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Zahtjev za Bluetooth uparivanje"</string>
    <string name="bluetooth_enter_pin_msg" msgid="5698297871117529185">"Za uparivanje s uređajem:<xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Upišite potreban PIN uređaja:"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="2220143735340367939">"Za uparivanje s uređajem:<xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Upišite potrebnu zaporku uređaja:"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"PIN sadrži slova ili simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Obično 0000 ili 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Možda biste također trebali unijeti ovaj PIN i na drugi uređaj."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Možda ćete ovaj pristupni kôd trebati unijeti i na drugi uređaj."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Za uparivanje s:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Uvjerite se da prikazuje ovaj pristupni kôd:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Od:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Upariti se s ovim uređajem?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Za uparivanje s uređajem:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>upišite:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g> na tom uređaju pa pritisnite tipke Return ili Enter."</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Upari"</string>
    <string name="bluetooth_pairing_accept_all_caps" msgid="6061699265220789149">"UPARI"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Odustani"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Uparivanje s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> nije bilo moguće."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Uparivanje s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> nije bilo moguće zbog netočnog PIN-a ili zaporke."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Komunikacija s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> nije moguća."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Uparivanje odbio uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Nije moguće povezati se na <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Skeniranjem traži uređaje"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Osvježi"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Traženje..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Postavke uređaja"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Upareni uređaj"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Naziv"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Internetska veza"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Tipkovnica"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontakti i povijest poziva"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Želite li uparivanje s ovim uređajem?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Želite li dijeliti telefonski imenik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi pristupiti vašim kontaktima i povijesti poziva."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> traži uparivanje s Bluetoothom. Kada se poveže, moći će pristupiti kontaktima i povijesti poziva."</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Spareni uređaji"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Dostupni uređaji"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nema dostupnih uređaja"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Poveži"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Isključi"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Upari i poveži"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Razdvoji par"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Isključi i razdvoji par"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Opcije…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Napredno"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Napredni Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Kada je Bluetooth uključen, uređaj može komunicirati s ostalim Bluetooth uređajima u blizini."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Poveži se na..."</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Medijski zvuk"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Zvuk telefona"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Prijenos datoteke"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Ulazni uređaj"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Pristup internetu"</string>
    <string name="bluetooth_profile_pbap" msgid="5372051906968576809">"Dijeljenje kontakata"</string>
    <string name="bluetooth_profile_pbap_summary" msgid="6605229608108852198">"Upotrijebi za dijeljenje kontakata"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Dijeljenje internetske veze"</string>
    <string name="bluetooth_profile_map" msgid="5465271250454324383">"Pristup porukama"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen sa zvuka medija."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Handsfree zvuk za uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen s ulaznog uređaja."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Pristup internetu putem uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će prekinut."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="5455448395850929200">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen iz dijeljenja internetske veze ovog tableta."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5266851881175033601">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen iz dijeljenja internetske veze ovog telefona."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Upareni Bluetooth uređaj"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Poveži"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Povežite se s Bluetooth uređajem"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Upotrijebi za"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Preimenuj"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Svi dolazni prijenosi datoteka"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"Povezano s medijskim zvukom"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Povezano sa telefonskim zvukom"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Povezano s poslužiteljem za prijenos datoteka"</string>
    <string name="bluetooth_map_profile_summary_connected" msgid="8191407438851351713">"Povezano s kartom"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Niste povezani s poslužiteljem za prijenos datoteka"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Povezano s ulaznim uređajem"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Povezano s uređajem za pristup internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Dijeljenje lokalne internetske veze s uređajem"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Koristi za medijski zvuk"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Koristi za telefonski zvuk"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Koristi za prijenos datoteke"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Upotrijebi za ulaz"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Upotrijebi za pristup internetu"</string>
    <string name="bluetooth_map_profile_summary_use_for" msgid="5154200119919927434">"Upotreba za kartu"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Postavke priključne stanice"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Koristi priključnu stanicu za zvuk"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Kao telefonski zvučnik"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Za glazbu i medije"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapamti postavke"</string>
    <string name="wifi_assistant_intro_setup" msgid="4605105515416995110">"Novo!\nWi‑Fi Assistant"</string>
    <string name="wifi_assistant_no_thanks" msgid="2776983751990143934">"NE, HVALA"</string>
    <string name="wifi_assistant_setup" msgid="3772423650475730906">"POSTAVI"</string>
    <string name="wifi_assistant_card_message" msgid="107811647784658536">"Automatski se povežite s dostupnim mrežama pomoću Wi‑Fi Assistanta."</string>
    <string name="wifi_assistant_title" msgid="2553267316621598101">"Wi‑Fi Assistant"</string>
    <string name="wifi_assistant_title_message" msgid="1270518944209872345">"Google Wi‑Fi Assistant automatski vas povezuje s najboljom dostupnom Wi‑Fi mrežom"</string>
    <string name="wifi_assistant_explanation_message" msgid="4242611602422534795">"Google Wi‑Fi Assistant otkriva mreže koje su vam dostupne i povezuje vaš uređaj s jednom od njih brzo i pouzdano."</string>
    <string name="wifi_assistant_vpn_message" msgid="5474437939154729312">"Za zaštitu vaših podataka Google Wi‑Fi Assistant pruža sigurnu VPN vezu putem Google poslužitelja."</string>
    <string name="wifi_assistant_activity_no_thanks" msgid="611984000647643330">"Ne, hvala"</string>
    <string name="wifi_assistant_activity_yes" msgid="529603077646719710">"DA, U REDU"</string>
    <string name="wifi_assistant_dialog_title" msgid="9130141448000161787">"Zahtjev za povezivanje"</string>
    <string name="wifi_assistant_dialog_message" msgid="6483823815004886979">"Wi‑Fi Assistant želi postaviti VPN vezu za praćenje mrežnog prometa. Prihvatite samo pouzdani izvor."</string>
    <string name="wifi_assistant_dialog_notice" msgid="7459835068779476953">"pojavljuje se pri vrhu zaslona kada je VPN aktivan."</string>
    <string name="wifi_assistant_accept" msgid="7669587061174451722">"PRIHVAĆAM"</string>
    <string name="wifi_assistant_deny" msgid="7052767926493128944">"ODBIJ"</string>
    <string name="wifi_assistant_network_title" msgid="5870092585963985624">"Nadzor mreže"</string>
    <string name="wifi_assistant_permission_accepted" msgid="577392827888043634">"Dali ste Google Wi‑Fi Assistantu dopuštenje za postavljanje VPN veze, pa može pratiti mrežni promet."</string>
    <string name="wifi_assistant_open_app" msgid="4803044899535675063">"OTVORI APLIKACIJU"</string>
    <string name="wifi_display_settings_title" msgid="2925465988657380522">"Emitirani zaslon"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Omogući bežični prikaz"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"U blizini nema uređaja."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Povezivanje"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Povezan"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"U upotrebi"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Nedostupno"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Postavke zaslona"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Opcije bežičnog prikaza"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Zaboravi"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Naziv"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Dopusti razmjenu podataka kada tabletno računalo dodiruje drugi uređaj"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Dopusti razmjenu podataka kada telefon dodiruje drugi uređaj"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Spreman za prijenos sadržaja aplikacije NFC-om"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Isključeno"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Nije dostupno jer je NFC isključen"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Kada je ta značajka uključena, možete emitirati sadržaj aplikacije na drugi uređaj na kojem je omogućen NFC tako da držite uređaje jedan uz drugi. Na primjer, možete emitirati stranice Preglednika, videozapise s YouTubea, kontakte s Osoba i više.\n\nJednostavno približite jedan uređaj drugom (obično se njihove stražnje strane prislanjaju jedna uz drugu), a zatim dodirnite zaslon. Aplikacija određuje što će se emitirati."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Otkrivanje mrežne usluge"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Dopusti aplikacijama na drugim uređajima otkrivanje aplikacija na ovom uređaju"</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Uključite Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Postavke Wi-Fi-ja"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Postavljanje i upravljanje bežičnim pristupnim točkama"</string>
    <string name="wifi_setup_wizard_title" msgid="8242230950011819054">"Odaberite Wi-Fi mrežu"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Odaberite Wi‑Fi mrežu"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Uključivanje Wi-Fi-ja…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Isključivanje Wi-Fi-ja…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Pogreška"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"U načinu rada u zrakoplovu"</string>
    <string name="wifi_fail_to_scan" msgid="1265540342578081461">"Skeniranje mreža nije moguće"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Mrežna obavijest"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3716818008370391253">"Obavijesti uvijek kada je dostupna javna mreža"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Izbjegavati slabe veze"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7843672905900544785">"Ne upotrebljavaj Wi-Fi mrežu ako internetska veza nije zadovoljavajuća"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"Koristi samo mreže s dobrom internetskom vezom"</string>
    <string name="wifi_scan_always_available" msgid="3470564139944368030">"Traženje je uvijek dostupno"</string>
    <string name="wifi_scan_always_available_title" msgid="1518769058260729007">"Uvijek omogući pretraživanje"</string>
    <string name="wifi_scan_always_available_summary" msgid="5442775583708315387">"Neka Googleova usluga lokacije i druge aplikacije traže mreže, čak i kada je Wi-Fi isključen"</string>
    <string name="wifi_automatically_manage_title" msgid="6249976570008992746">"Automatski upravljaj Wi‑Fi vezom"</string>
    <!-- no translation found for wifi_automatically_manage_summary (6952470763378312488) -->
    <skip />
    <string name="wifi_assistant_setting_title" msgid="7891352922976664256">"Wi‑Fi Assistant"</string>
    <string name="wifi_assistant_setting_summary" msgid="8436161813951180466">"Google Wi‑Fi Assistant"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instaliranje certifikata"</string>
    <string name="wifi_scan_notify_text_location_on" msgid="8135076005488914200">"Radi poboljšavanja preciznosti i u neke druge svrhe Google i ostale aplikacije mogu tražiti mreže u blizini, čak i kada je Wi-Fi isključen. Ako ne želite da se to događa, idite na opcije Napredno &gt; Traženje je uvijek dostupno."</string>
    <string name="wifi_scan_notify_text_location_off" msgid="6323983741393280935">"Aplikacije mogu tražiti mreže u blizini, čak i kada je Wi-Fi isključen. Ako ne želite da se to događa, idite na opcije Napredno &gt; Traženje je uvijek dostupno."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="5340097010842405981">"Ne prikazuj ponovno"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Zadrži Wi-Fi tijekom mirovanja"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi‑Fi ostaje aktivan u mirovanju"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Pojavio se problem s promjenom postavke"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Poboljšaj učinkovitost"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizacija Wi-Fi-ja"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimiziraj potrošnju baterije kad je Wi-Fi uključen"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Ograniči bateriju za Wi‑Fi"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Dodaj mrežu"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Wi-Fi mreže"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"WPS gumb"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Više opcija"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Unos WPS PIN-a"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Izravni Wi-Fi"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Skeniraj"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Napredno"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Poveži s mrežom"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Zaboravi mrežu"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Izmijeni mrežu"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Piši na oznaku NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Da biste vidjeli dostupne mreže, uključite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Traženje Wi-Fi mreža…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="8280257225419947565">"Nemate dopuštenje za promjenu Wi‑Fi mreže."</string>
    <string name="wifi_other_network" msgid="1484433183857764750">"Dodaj još jednu mrežu"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Više"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Autom. postavljanje (WPS)"</string>
    <string name="wifi_required_info_text" msgid="7442238187557620087">"Da bi se postavljanje dovršilo, tablet mora pristupiti Wi‑Fi mreži. Nakon postavljanja možete izmjenjivati mobilnu podatkovnu vezu i Wi‑Fi."</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Napredne opcije"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Zaštićeno postavljanje Wi-Fi mreže"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Pokretanje WPS-a..."</string>
    <string name="wifi_wps_onstart_pbc" msgid="5940801028985255304">"Pritisnite gumb za zaštićeno postavljanje Wi-Fi mreže na svom usmjerivaču. Može se zvati \"WPS\" ili sadržavati ovaj simbol:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Unesite PIN <xliff:g id="NUMBER">%1$s</xliff:g> na svoj Wi-Fi usmjerivač. Postavljanje može potrajati do dvije minute."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"WPS uspio. Povezivanje s mrežom…"</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Povezano s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"WPS je već u tijeku, a do završetka može proteći do dvije minute"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"Zahtjev nije uspio. Pokušajte ponovo za nekoliko minuta."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Sigurnosna postavka (WEP) bežičnog usmjerivača nije podržana"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Sigurnosna postavka bežičnog usmjerivača (TKIP) nije podržana"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Autentifikacija nije uspjela. Pokušajte ponovo."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Otkrivena je još jedna WPS sesija. Pokušajte ponovo za nekoliko minuta."</string>
    <string name="wifi_ssid" msgid="641393708309146745">"Mrežni SSID"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Unesite SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Sigurnost"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Jakost signala"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Status"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Brzina veze"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Učestalost"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"IP adresa"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"EAP metoda"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"2. faza provjere autentičnosti"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"CA certifikat"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Korisnički certifikat"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identitet"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anoniman identitet"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Zaporka"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Pokaži zaporku"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"IP postavke"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nepromijenjeno)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(nije određeno)"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"Spremljeno"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Onemogućeno"</string>
    <string name="wifi_disabled_network_failure" msgid="3111321240793227690">"Izbjegavanje slabe internetske veze"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Problem u autentifikaciji"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Nije u rasponu"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS dostupan"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS dostupan)"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Unesite mrežnu zaporku"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Nema"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Radi poboljšanja preciznosti lokacije kao i u druge svrhe aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti pregledavanje mreže, čak i kada je Wi-Fi isključen.\n\nŽelite li to dozvoliti za sve aplikacije koje žele izvoditi pregledavanje?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Isključite putem opcije Napredno na dodatnom izborniku."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Dopusti"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Odbij"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Želite li se prijaviti radi povezivanja?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> zahtijeva prijavu na webu za povezivanje s mrežom."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"POVEŽI"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Poveži"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Povezivanje s mrežom nije uspjelo"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Zaboravi"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Zaboravljanje mreže nije uspjelo"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Spremi"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Spremanje mreže nije uspjelo"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Odustani"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Svejedno preskoči"</string>
    <string name="wifi_dont_skip" msgid="7350341524881124808">"Nemoj preskočiti"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="6761689889733331124">"UPOZORENJE: ako preskočite Wi‑Fi, tablet će upotrebljavati samo mobilne podatke za početna preuzimanja i ažuriranja. Da biste izbjegli moguće troškove za prijenos podataka, povežite se s Wi-Fi-jem."</string>
    <string name="wifi_skipped_message" product="device" msgid="1385490367826852775">"UPOZORENJE: ako preskočite Wi‑Fi, uređaj će upotrebljavati samo mobilne podatke za početna preuzimanja i ažuriranja. Da biste izbjegli moguće troškove za prijenos podataka, povežite se s Wi-Fi-jem."</string>
    <string name="wifi_skipped_message" product="default" msgid="6084295135297772350">"UPOZORENJE: ako preskočite Wi‑Fi, telefon će upotrebljavati samo mobilne podatke za početna preuzimanja i ažuriranja. Da biste izbjegli moguće troškove za prijenos podataka, povežite se s Wi-Fi-jem."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="2393880108322835846">"UPOZORENJE: ako preskočite Wi‑Fi, tablet neće imati internetsku vezu za početna preuzimanja ili ažuriranja."</string>
    <string name="wifi_and_mobile_skipped_message" product="device" msgid="1707391993265558787">"UPOZORENJE: ako preskočite Wi‑Fi, uređaj neće imati internetsku vezu za početna preuzimanja ili ažuriranja."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="1556858507920033022">"UPOZORENJE: ako preskočite Wi‑Fi, telefon neće imati internetsku vezu za početna preuzimanja ili ažuriranja."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Tabletno računalo nije se moglo povezati s ovom Wi-Fi mrežom."</string>
    <string name="wifi_connect_failed_message" product="device" msgid="8870885845666880869">"Uređaj se nije mogao povezati s tom Wi‑Fi mrežom."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefon se nije mogao povezati s ovom Wi-Fi mrežom."</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Spremljene mreže"</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Napredni Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_title" msgid="3655327399028584656">"Pojas frekvencije Wi-Fi mreže"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Odredi raspon frekvencije rada"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Problem pri postavljanju pojasa frekvencije."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC adresa"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP adresa"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Spremljene mreže"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"IP postavke"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Spremi"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Odustani"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Upišite važeću IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Upišite važeću adresu pristupnika."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Upišite važeću DNS adresu."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Upišite prefiks mreže duljine između 0 i 32 znaka."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Pristupnik"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Duljina mrežnog prefiksa"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Izravni Wi-Fi"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Podaci o uređaju"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Zapamti tu vezu"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Traženje uređaja"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Traženje..."</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Preimenuj uređaj"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Paralelni uređaji"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Zapamćene grupe"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Povezivanje nije bilo moguće."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Preimenovanje uređaja nije uspjelo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Isključiti?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Ako odspojite, prekinut će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Ako odspojite, prekinut će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g> i <xliff:g id="PEER_COUNT">%2$s</xliff:g> te ostalim uređajima."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Otkazati pozivnicu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Želite li otkazati pozivnicu za povezivanje s korisnikom <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Zaboraviti ovu grupu?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Prijenosna Wi-Fi žarišna točka"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Wi‑Fi žarišna točka"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="3800646230853724318">"Koristi mob. vezu za pružanje WiFi mreže"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Uključivanje žarišne točke…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Isključivanje žarišne točke…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Aktivna je prijenosna Wi-Fi pristupna točka <xliff:g id="NETWORK_SSID">%1$s</xliff:g>"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Pogreška prijenosne Wi-Fi žarišne točke"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Postavljanje Wi-Fi žarišne točke"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Postavljanje Wi‑Fi žar. točke"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5618031116920832182">"AndroidAP WPA2 PSK pokretna Wi-Fi točka"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g> prijenosna Wi-Fi žarišna točka"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="home_settings" msgid="212375129455718176">"Početna"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Prikaz"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvuk"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Glasnoća"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Glazbeni efekti"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Glasnoća zvona"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibracija ako je bešumno"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Zadani zvuk obavijesti"</string>
    <string name="heads_up_enabled_title" msgid="1031078221910921622">"Skočni za visoki prioritet"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Zvuk zvona"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Obavijest"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Koristi glasnoću dolaznog poziva za obavijesti"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Ne podržava radne profile"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Zadani zvuk obavijesti"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Mediji"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Postavite glasnoću za glazbu i videozapise"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarm"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Postavke zvuka za dodanu priključnu stanicu"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tonovi biranja"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Zvukovi dodirivanja"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvukovi zaključavanja zaslona"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Vibracija na dodir"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Uklanjanje buke"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Glazba, videozapisi, igre i drugi mediji"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Melodija zvona i obavijesti"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Obavijesti"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmi"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Isključivanje zvuka zvona i obavijesti"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Isključivanje zvuka glazbe i drugih medija"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Isključivanje zvuka obavijesti"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Isključivanje zvuka alarma"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Priključna stanica"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Postavke priključne stanice"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Postavke za dodanu priključnu stanicu za računalo"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Postavke za priključnu stanicu automobila"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tabletni uređaj nije priključen na priključni uređaj"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon nije priključen"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Postavke za priključnu stanicu"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Priključna stanica nije pronađena"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Prije postavljanja zvuka priključne stanice trebate na nju postaviti tabletno računalo."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Prije postavljanja zvuka priključne stanice trebate na nju postaviti telefon."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvuk priključivanja stanice"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Reproduciraj zvuk pri umetanju ili uklanjanju tabletnog uređaja iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Reproduciraj zvuk kod umetanja ili uklanjanja telefona s priključne stanice"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"Ne reproduciraj zvuk pri umetanju ili uklanjanju tabletnog uređaja iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"Ne reproduciraj zvuk kod umetanja ili uklanjanja telefona s priključne stanice"</string>
    <string name="account_settings" msgid="6403589284618783461">"Računi"</string>
    <string name="category_personal" msgid="1299663247844969448">"Osobno"</string>
    <string name="category_work" msgid="8699184680584175622">"Posao"</string>
    <string name="search_settings" msgid="1910951467596035063">"Pretraži"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Upravljajte postavkama pretraživanja i poviješću"</string>
    <string name="display_settings" msgid="7965901687241669598">"Prikaz"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Automatski zakreni zaslon"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Prebaci orijentaciju automatski pri rotaciji tabletnog uređaja"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Promijeni orijentaciju automatski kod rotacije telefona"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Prebaci orijentaciju automatski pri rotaciji tabletnog uređaja"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Promijeni orijentaciju automatski kod rotacije telefona"</string>
    <string name="brightness" msgid="8480105032417444275">"Razina svjetline"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Svjetlina"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Podesite svjetlinu zaslona"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Prilagodljiva svjetlina"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Optimiziranje razine svjetline za postojeće svjetlo"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Mirovanje"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Zaslon se isključuje"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Nakon <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Pozadinska slika"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Odabir pozadinske slike iz"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Sanjarenje"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Kada je uređaj na priključnoj stanici ili kada miruje i puni se"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Bilo koje"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Tijekom punjenja"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Isključeno"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Da biste kontrolirali događaje dok je telefon na priključnoj stanici i/ili dok miruje, uključite značajku Sanjarenje."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Kada sanjariti"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Započni sad"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Postavke"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatska svjetlina"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Aktivacija podizanjem"</string>
    <string name="doze_title" msgid="2259176504273878294">"Ambijentalni zaslon"</string>
    <string name="doze_summary" msgid="8300817661725517088">"Aktiviraj zaslon prilikom podizanja uređaja ili kada stigne obavijest"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Veličina fonta"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Veličina fonta"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Postavke zaključavanja SIM kartice"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Postavite zaključavanje SIM kartice"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"SIM kartica je zaključana"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Zaključaj SIM karticu"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Traži PIN za upotrebu tabletnog uređaja"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Potreban je PIN za upotrebu telefona"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Traži PIN za upotrebu tabletnog uređaja"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Potreban je PIN za upotrebu telefona"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Promijeni PIN za SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"SIM PIN"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zaključaj SIM karticu"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Otključaj SIM karticu"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Stari SIM PIN"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Novi SIM PIN"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Ponovo unesite novi PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"SIM PIN"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Netočan PIN"</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"PIN-ovi se ne podudaraju"</string>
    <string name="sim_change_failed" msgid="304964924772218382">"Nije moguće promijeniti PIN.\nPIN je možda netočan."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Uspješno je promijenjen PIN SIM-a"</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"Nije moguće promijeniti stanje zaključanosti SIM kartice.\nMožda je PIN pogrešan."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"U redu"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Odustani"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Pronađeno je više SIM-ova"</string>
    <string name="sim_multi_sims_summary" msgid="7018740080801483990">"Odaberite SIM putem kojeg želite upotrebljavati mobilni prijenos podataka."</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Netočan PIN kôd SIM kartice; sada morate kontaktirati svog mobilnog operatera da bi otključao vaš uređaj."</string>
  <plurals name="wrong_pin_code">
    <item quantity="one" msgid="4840607930166101114">"Netočan PIN kôd SIM kartice; imate još <xliff:g id="NUMBER">%d</xliff:g> pokušaj prije nego što budete morali kontaktirati svog mobilnog operatera da bi otključao vaš uređaj."</item>
    <item quantity="other" msgid="77103619544346451">"Netočan PIN kôd SIM kartice; imate još ovoliko preostalih pokušaja: <xliff:g id="NUMBER">%d</xliff:g>."</item>
  </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Operacija PIN-a SIM kartice nije uspjela!"</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Status tabletnog uređaja"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Status telefona"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Ažuriranja sustava"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Verzija sustava Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Broj modela"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID opreme"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Osnovna verzija"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Verzija jezgre"</string>
    <string name="build_number" msgid="3075795840572241758">"Broj međuverzije"</string>
    <string name="selinux_status" msgid="6212165375172061672">"Status SELinuxa"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Nije dostupno"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Status"</string>
    <string name="device_status" msgid="607405385799807324">"Status"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Status baterije, mreže i ostale informacije"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefonski broj, signal itd."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Pohranjivanje"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Postavke pohrane"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Isključi USB memoriju, prikaži dostupnu pohranu"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Isključi SD karticu, prikaži vidljivo mjesto za pohranu"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Moj telefonski broj"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"PRL verzija"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="952552009117455166">"Vrsta mobilne mreže"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informacije o operateru"</string>
    <string name="status_data_state" msgid="4578972321533789767">"Stanje mobilne mreže"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stanje usluge"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Jakost signala"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Mreža"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"MAC adresa Wi-Fi-ja"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Bluetooth adresa"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Serijski broj"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Nije dostupno"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Vrijeme aktivnosti"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Vrijeme bez mirovanja"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Unutarnja pohrana"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"USB memorija"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"SD kartica"</string>
    <string name="memory_available" msgid="5052397223077021181">"Dostupno"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Dostupno (samo za čitanje)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Ukupno prostora"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Izračun u tijeku..."</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Aplikacije (podaci aplikacije i medijski sadržaj)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Mediji"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Preuzimanja"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Slike, videozapisi"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Audio (glazba, melodije zvona, podkastovi itd.)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Razno"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Podaci iz predmemorije"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Isklj. dijeljenu pohranu"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Isključi SD karticu"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Isključi unutarnju USB memoriju"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Isključite karticu SD radi sigurnog uklanjanja"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Umetni USB mem. za uklj."</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Umetnite SD karticu za uključivanje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Uključi memoriju USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Uključivanje SD kartice"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Izbriši USB memoriju"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Izbriši karticu SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Briše sve podatke na unutarnjoj memoriji USB, poput glazbe ili fotografija"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Briše sve podatke na kartici SD, poput glazbe i fotografija"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Brisati podatke iz predmemorije?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Obrisat ćete predmem. podatke za sve aplikacije."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"MTP ili PTP funkcija aktivna je"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Isključiti USB pohranu?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Isključiti SD karticu?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Ako isključite USB pohranu, neke aplikacije koje upotrebljavate zaustavit će se i mogu biti nedostupne dok ponovo ne uključite USB pohranu."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Ako isključite SD karticu, dio aplikacija koje upotrebljavate zaustavit će se i možda će biti nedostupne sve dok ponovo ne uključite SD karticu."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="4346280469528260684">"USB pohrana ne može se isključiti. Pokušajte ponovo kasnije."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"Nije moguće isključiti SD karticu. Pokušajte ponovo."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Memorija USB bit će isključena."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Kartica SD bit će isključena."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Isključivanje"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Isključivanje u tijeku"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Ponestaje prostora za pohranu"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Neke funkcije sustava, kao što je sinkroniziranje, može neće ispravno funkcionirati. Pokušajte osloboditi prostor brisanjem stavki ili ih otkvačite, primjerice aplikacije ili medijski sadržaj."</string>
    <string name="storage_menu_usb" msgid="5708207885333243384">"Povezivanje USB-a i računala"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Povezivanje USB-a i računala"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Poveži kao"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Uređaj za medije (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Omogućuje prijenos medijskih datoteka u OS Windows ili Androidovim prijenosom datoteka na Mac (pogledajte www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Fotoaparat (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"Omogućuje vam prijenos fotografija pomoću softvera fotoaparata i prijenos bilo koje datoteke na računala koji ne podržavaju MTP"</string>
    <string name="usb_label_installer_cd" msgid="4331173824920630215">"Instaliraj alate za prijenos datoteka"</string>
    <string name="storage_other_users" msgid="808708845102611856">"Drugi korisnici"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Status baterije"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Razina baterije"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN-ovi"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Uredi pristupnu točku"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nije postavljeno"</string>
    <string name="apn_name" msgid="4115580098369824123">"Ime"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Korisničko ime"</string>
    <string name="apn_password" msgid="5412301994998250968">"Zaporka"</string>
    <string name="apn_server" msgid="2436185314756372858">"Poslužitelj"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"MMS proxy"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"MMS priključak"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Vrsta provjere autentičnosti"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Ništa"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ili CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Vrsta APN-a"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"APN protokol"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokol APN-a za roaming"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Omogući/onemogući APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN omogućen"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN onemogućen"</string>
    <string name="bearer" msgid="594270280031923558">"Nositelj"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Vrsta MVNO-a"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Vrijednost MVNO-a"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Izbriši APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Novi APN"</string>
    <string name="menu_save" msgid="8109345640668285399">"Spremi"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Odbaci"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Polje naziva ne može biti prazno."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"APN ne može biti prazan."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"MCC polje mora imati 3 znamenke."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Polje MNC mora imati 2 ili 3 znamenke."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Vraćanje zadanih APN postavki"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Ponovo postavi na zadano"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Poništavanje zadanih postavki APN-a dovršeno."</string>
    <string name="device_reset_title" msgid="2384019005638768076">"Vrati uređaj na zadano"</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Vraćanje na tvorničko stanje"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Briše sve podatke na tabletnom uređaju"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Izbriši sve podatke na telefonu"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"To će izbrisati sve podatke s "<b>"unutarnje pohrane"</b>" tabletnog računala, uključujući:\n\n"<li>"vaš Google račun"</li>\n<li>"podatke i postavke sustava i aplikacija"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"To će izbrisati sve podatke s "<b>"unutarnje pohrane"</b>" telefona, uključujući:\n\n"<li>"vaš Google račun"</li>\n<li>"podatke i postavke sustava i aplikacija"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Trenutačno ste prijavljeni na sljedeće račune:\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Glazba"</li>\n<li>"Fotografije"</li>\n<li>"Ostali korisnički podaci"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Da biste izbrisali glazbu, slike i ostale korisničke podatke, "<b>"USB pohrana"</b>" treba biti izbrisana."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Da biste izbrisali glazbu, slike i ostale korisničke podatke, trebate izbrisati "<b>"SD karticu"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Izbriši USB memoriju"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Izbriši karticu SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Izbrisati sve podatke u unutarnjoj USB pohrani, poput glazbe ili fotografija"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Izbrisati sve podatke na SD kartici, na primjer, glazbu ili fotografije"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Poništi tabletni uređaj"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Poništi telefon"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Izbrisati sve osobne podatke i preuzete aplikacije? Radnja se ne možete poništiti!"</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Izbriši sve"</string>
    <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Iscrtajte uzorak za otključavanje"</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Da biste potvrdili vraćanje na tvorničke postavke, trebate nacrtati svoj uzorak za otključavanje."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Nije došlo do poništavanja jer nije dostupna usluga brisanja sustava."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Poništiti?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Vraćanje na tvorničko stanje nije dostupno za ovog korisnika"</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Izbriši USB memoriju"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Izbriši karticu SD"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Briše sve podatke USB memorije"</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Briše sve podatke na SD kartici"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Izbrisati čitavu USB memoriju? Izgubit ćete "<b>"sve"</b>" pohranjene podatke!"</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Izbrisati SD karticu? Izgubit ćete "<b>"sve"</b>" podatke na kartici!"</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Izbriši USB memoriju"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Izbriši karticu SD"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Izbrisati USB pohranu i sve u njoj pohranjene datoteke? Radnja se ne može poništiti!"</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Izbrisati SD karticu i sve pohranjene datoteke na njoj? Radnja se ne može poništiti!"</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Izbriši sve"</string>
    <string name="media_format_gesture_prompt" msgid="3109349468816856670">"Iscrtajte uzorak za otključavanje"</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"Morate iscrtati uzorak za otključavanje kako biste potvrdili da želite izbrisati USB memoriju."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"Trebate iscrtati svoj uzorak za otključavanje kako biste potvrdili da želite izbrisati SD karticu."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Postavke poziva"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Postavite govornu poštu, preusmjeravanje poziva, ID pozivatelja"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"USB dijeljenje veze"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Prijen. pristupna točka"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Dijeljenje Bluetoothom veze"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Dijeljenje veze"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Dijeljenje veze i prijenosni pristup"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Dijeljenje USB-om"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"USB priključen, uključite za ograničenje"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Ograničeno"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Modemsko povezivanje nije moguće ako se upotrebljava USB pohrana"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"USB nije priključen"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Povežite se radi uključivanja"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Pogreška ograničenja USB-a"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Dijeljenje veze Bluetoothom"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Dijeljenje internetske veze ovog tableta"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Dijeljenje internetske veze ovog uređaja"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Internetska veza tableta dijeli se s 1 uređajem"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Internetska veza telefona dijeli se s 1 uređajem"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Broj uređaja s kojima se dijeli int. veza tableta: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Broj uređaja s kojima se dijeli int. veza telefona: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="1790242032929221788">"Dijeljenje internetske veze ovog uređaja <xliff:g id="DEVICE_NAME">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Ne dijeli se internetska veza ovog tableta"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Ne dijeli se internetska veza ovog telefona"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Nema modemskog povezivanja"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"Veza se ne može dijeliti s više od <xliff:g id="MAXCONNECTION">%1$d</xliff:g> uređaja."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> će biti oslobođen."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Pomoć"</string>
    <string name="network_settings_title" msgid="4871233236744292831">"Mobilne mreže"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Mobilni paket"</string>
    <string name="sms_application_title" msgid="6134351177937015839">"Zadana aplikacija za SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Želite li promijeniti aplikaciju za SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Želite li upotrijebiti aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> kao svoju aplikaciju za SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Želite li upotrijebiti aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> kao svoju aplikaciju za SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Želite li zamijeniti Wi‑Fi assistanta?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Želite li upotrebljavati aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g>, a ne <xliff:g id="CURRENT_APP">%2$s</xliff:g>, za upravljanje mrežnim vezama?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Želite li upotrebljavati aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Nepoznati operater SIM kartice"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"%1$s nema poznatu web-lokaciju za niz usluga"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Umetnite SIM karticu i pokrenite ponovo"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Povežite se s internetom"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja lokacija"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Način"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Visoka preciznost"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Štednja baterije"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Samo uređaj"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Lokacija je isključena"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Nedavni zahtjevi za lokaciju"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Nijedna aplikacija nije nedavno zatražila lokaciju"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Usluge lociranja"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Visoka potrošnja baterije"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Niska potrošnja baterije"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Način lokacije"</string>
    <string name="location_mode_high_accuracy_description" msgid="5349014493087338351">"Upotreba GPS-a, Wi‑Fi i mobilnih mreža za utvrđivanje lokacije"</string>
    <string name="location_mode_battery_saving_description" msgid="7581657383062066461">"Upotreba Wi‑Fi i mobilnih mreža za utvrđivanje lokacije"</string>
    <string name="location_mode_sensors_only_description" msgid="7178415350457794366">"Za određivanje lokacije upotrebljava se GPS"</string>
    <string name="location_network_based" msgid="6010456018401296590">"Lokacija Wi‑Fi i mobilne mreže"</string>
    <string name="location_neighborhood_level" msgid="5626515380188353712">"Omogućite aplik. da upotrebljavaju Googleovu uslugu lokacije za brže lociranje. Anonimni podaci prikupljat će se i slati Googleu."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Lokacija utvrđena pomoću Wi-Fi-ja"</string>
    <string name="location_gps" msgid="8392461023569708478">"GPS sateliti"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Omogućite aplikacijama da upotrebljavaju GPS na tabletnom računalu za označavanje vaše lokacije"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Omogućite aplikacijama da upotrebljavaju GPS na vašem telefonu za označavanje vaše lokacije"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Koristite potpomognuti GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Koristi poslužitelj za pomoć GPS-u (isključite za smanjenje mrežnog opterećenja)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Koristi poslužitelj za pomoć GPS-u (isključite za bolji rad GPS-a)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Lokac. i Google pretraživanje"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Neka Google upotrebljava vašu lokaciju za poboljšanje rezultata pretraživanja i drugih usluga"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Pristup mojoj lokaciji"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Omogućite da aplikacije koje su tražile vaše dopuštenje upotrebljavaju informacije o vašoj lokaciji"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Izvori lokacije"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"O tabletnom uređaju"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"O telefonu"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Prikaži pravne informacije, status, verziju softvera"</string>
    <string name="legal_information" msgid="5769301644270604095">"Pravne informacije"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Suradnici"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Informacije o propisima"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autorska prava"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenca"</string>
    <string name="terms_title" msgid="7697580845616764642">"Uvjeti i odredbe"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Otvori licence izvora"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Došlo je do problema s učitavanjem licenci."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Učitavanje…"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Sigurnosne informacije"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Sigurnosne informacije"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Nemate podatkovnu vezu. Da biste tu informaciju vidjeli sada, idite na stranicu %s s bilo kojeg računala povezanog s internetom."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Učitavanje…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Odaberite svoju zaporku"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Odaberite uzorak"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Odaberite PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Potvrdite svoju zaporku"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potvrdite uzorak"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Potvrdite svoj PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Zaporke se ne podudaraju"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"PIN-ovi se ne podudaraju"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Odabir načina otključavanja"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Zaporka je postavljena"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"PIN je postavljen"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Uzorak je postavljen"</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Sigurnost zaslona"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Izmijeni uzorak za otključavanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Promijeni PIN za otključavanje"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Potvrdi spremljeni uzorak"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Pokušajte ponovo:"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Iscrtajte uzorak za otključavanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Pritisnite Izbornik za pomoć."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Maknite prst ako ste gotovi"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Povežite barem ovoliko točaka: <xliff:g id="NUMBER">%d</xliff:g>. Pokušajte ponovo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Uzorak je snimljen"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Ponovno iscrtajte uzorak za potvrdu"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Vaš novi uzorak za otključavanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potvrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Iscrtajte ponovno"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Pokušaj ponovo"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Nastavi"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Uzorak za otključavanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Potreban je uzorak"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Morate iscrtati uzorak za otključavanje zaslona"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Učini uzorak vidljivim"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Vibracija na dodir"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Gumb napajanja odmah se blokira"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Osim kad ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> drži otključanim"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Postavi uzorak za otključavanje"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Izmijeni uzorak za otključavanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kako iscrtati uzorak za otključavanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Previše netočnih pokušaja!"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikacija nije instalirana na vašem telefonu."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Upravljanje aplikacijama"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Upravljanje instaliranim aplikacijama i njihovo uklanjanje"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Aplikacije"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Upravljanje aplikacijama, postavljanje prečaca za brzo pokretanje"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Postavke aplikacije"</string>
    <string name="install_applications" msgid="4872012136210802181">"Nepoznati izvori"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Dopusti sve izvore aplikacija"</string>
    <string name="install_unknown_applications_title" msgid="663831043139080992">"Omogućuje instaliranje aplikacija iz izvora koji nisu Google Play"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Dopustite instalaciju aplikacija iz nepoznatih izvora"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Vaše tabletno računalo i osobni podaci izloženiji su napadima aplikacija iz nepoznatih izvora. Prihvaćate isključivu odgovornost za svu štetu nastalu na tabletnom računalu ili gubitak podataka uzrokovan upotrebom tih aplikacija."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Vaš telefon i osobni podaci izloženiji su napadima aplikacija iz nepoznatih izvora. Prihvaćate isključivu odgovornost za svu štetu nastalu na telefonu ili gubitak podataka uzrokovan upotrebom tih aplikacija."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Napredne postavke"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Omogućiti više opcija postavki"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informacije o aplikaciji"</string>
    <string name="storage_label" msgid="8700867073480107253">"Prostor za pohranu"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Pokretanje prema zadanim postavkama"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Zadane postavke"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Kompatibilnost zaslona"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Dozvole"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Predmemorija"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Očisti predmemoriju"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Predmemorija"</string>
    <string name="controls_label" msgid="7611113077086853799">"Kontrole"</string>
    <string name="force_stop" msgid="7435006169872876756">"Prisilno zaustavi"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Ukupno"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Aplikacija"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"USB aplikacija za pohranjivanje"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Podaci"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"USB uređaj za pohranu podataka"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"SD kartica"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Deinstaliraj"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Deinstaliraj za sve korisnike"</string>
    <string name="install_text" msgid="884360662922471113">"Instaliraj"</string>
    <string name="disable_text" msgid="6544054052049395202">"Onemogući"</string>
    <string name="enable_text" msgid="9217362512327828987">"Omogući"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Izbriši podatke"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Deinstaliraj ažuriranja"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Odlučili ste da se ta aplikacija pokreće prema zadanim postavkama za neke radnje."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Odlučili ste dopustiti ovoj aplikaciji izradu widgeta i pristupanje njihovim podacima."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nema zadanih postavki."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Izbriši zadane postavke"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ta aplikacija možda nije dizajnirana za vaš zaslon. Ovdje možete provjeriti kako se prilagođava vašem zaslonu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Pitaj pri pokretanju"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Skaliranje aplikacije"</string>
    <string name="unknown" msgid="1592123443519355854">"Nepoznato"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Poredaj prema nazivu"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Poredaj po veličini"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Prikaži pokrenute usluge"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Prikaži procese iz predmemorije"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Poništi postavke"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Poništiti postavke?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Sve postavke za sljedeće vratit će se na zadano:\n\n "<li>"onemogućene aplikacije"</li>\n" "<li>"onemogućene obavijesti aplikacija"</li>\n" "<li>"zadane aplikacije za radnje"</li>\n" "<li>"ograničenja pozadinskih podataka za aplikacije"</li>\n" "<li>"sva ograničenja dozvola."</li>\n\n" Nećete izgubiti podatke nijedne aplikacije."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Poništi aplikacije"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Upravljaj prostorom"</string>
    <string name="filter" msgid="2018011724373033887">"Filtar"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Odabir opcije filtra"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Sve"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Onemogućeno"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Preuzeto"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Pokrenuto"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Memorija USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na SD kartici"</string>
    <string name="disabled" msgid="9206776641295849915">"Onemogućeno"</string>
    <string name="not_installed" msgid="1475144352069281880">"Nije instalirano"</string>
    <string name="no_applications" msgid="7336588977497084921">"Nema aplikacija."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Unutarnja pohrana"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Memorija USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Poh. SD kartice"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Ponovni izračun veličine…"</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Izbrisati podatke aplikacija?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Svi podaci ove aplikacije bit će trajno izbrisani. To uključuje sve datoteke, postavke, račune, baze podataka itd."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"U redu"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Odustani"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"Aplikacija nije pronađena na popisu instaliranih aplikacija."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Podaci aplikacije nisu se mogli izbrisati."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Deinstalirati ažuriranja?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Sva ažuriranja ove aplikacije sustava Android bit će deinstalirana."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Izbriši podatke"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Brisanje podataka za aplikaciju nije uspjelo."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Ova aplikacija može pristupiti sljedećim stavkama na vašem tabletnom računalu:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Ova aplikacija može pristupiti sljedećim stavkama na vašem telefonu:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Ta aplikacija može pristupiti sljedećim stavkama na vašem tabletnom računalu. Radi poboljšanja uspješnosti i smanjenja upotrebe memorije neke od tih dozvola dostupne su aplikaciji <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> jer izvodi isti proces kao i <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Ta aplikacija može pristupiti sljedećim stavkama na vašem telefonu. Radi poboljšanja uspješnosti i smanjenja upotrebe memorije neke od tih dozvola dostupne su aplikaciji <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> jer izvodi isti proces kao i <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> i <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> i <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Ova aplikacija može naplaćivati upotrebu:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Pošalji premium SMS"</string>
    <string name="computing_size" msgid="1599186977475211186">"Izračunavanje..."</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Nije moguće izračunati veličinu paketa."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Nemate instaliranih aplikacija treće strane."</string>
    <string name="version_text" msgid="9189073826278676425">"verzija <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Premjesti"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Premjesti na tabletni uređaj"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Premjesti na telefon"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Premjesti na USB memoriju"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Premjesti na SD karticu"</string>
    <string name="moving" msgid="6431016143218876491">"Premještanje"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nema dovoljno prostora za pohranu."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"Aplikacija ne postoji."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplikacija ima zaštitu protiv kopiranja."</string>
    <string name="invalid_location" msgid="2786030127356312746">"Lokacija instalacije nije važeća."</string>
    <string name="system_package" msgid="6222593098063037137">"Ažuriranja sustava nije moguće instalirati na vanjskom mediju."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Prisilno zaustaviti?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Ako silom zaustavite aplikaciju, možda će se ponašati nepredviđeno."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Premještanje aplikacije nije uspjelo. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Željena lokacije instalacije"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Promijenite željenu lokaciju instalacije za nove aplikacije."</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Onemogući ugrađenu aplikaciju?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Ako onemogućite ugrađenu aplikaciju, druge će se aplikacije možda ponašati nepredviđeno."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Izbrisati podatke i onemogućiti aplikaciju?"</string>
    <string name="app_special_disable_dlg_text" msgid="3447657419284854195">"Ako onemogućite ugrađenu aplikaciju, druge aplikacije mogu se ponašati nepredviđeno. Također će se izbrisati vaši podaci."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Isključiti obavijesti?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Ako isključite obavijesti za ovu aplikaciju, možda ćete propustiti važna upozorenja i ažuriranja."</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Radnje aplikacija"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"U tijeku"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nikada nije upotrebljavano)"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Upotreba pohrane"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Prikaz pohrane koju upotrebljavaju aplikacije"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Pokrenute usluge"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Pogledajte i nadzirite pokrenute procese"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Ponovno pokretanje"</string>
    <string name="cached" msgid="1059590879740175019">"Pozadinski proces u predmemoriji"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Ništa se ne izvodi."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Pokrenula aplikacija."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> slobodno"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> up."</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Korisnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Uklonjeni korisnik"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"Broj procesa: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, broj usluga: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesa i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Memorija uređaja"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Upotreba RAM-a za aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sustav"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Dostupno"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Iskorišteno"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"U predmemoriji"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Pokrenuta aplikacija"</string>
    <string name="no_services" msgid="7133900764462288263">"Nije aktivno"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Usluge"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesi"</string>
    <string name="service_stop" msgid="6369807553277527248">"Zaustavi"</string>
    <string name="service_manage" msgid="1876642087421959194">"Postavke"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Ovu je uslugu pokrenula njezina aplikacija. Zaustavljanje može uzrokovati pad aplikacije."</string>
    <string name="heavy_weight_stop_description" msgid="2979218727598321095">"Ova se aplikacija ne može sigurno zaustaviti. Ako je zaustavite, mogli biste izgubiti trenutačan rad."</string>
    <string name="background_process_stop_description" msgid="5034773197139654588">"Ovo je proces stare aplikacije koja se još uvijek izvršava u slučaju da opet bude potrebna. Obično je nema potrebe zaustavljati."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutačno u upotrebi. Dodirnite Postavke za upravljanje."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Glavni proces u upotrebi."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Usluga <xliff:g id="COMP_NAME">%1$s</xliff:g> u upotrebi je."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Pružatelj <xliff:g id="COMP_NAME">%1$s</xliff:g> u upotrebi je."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Zaustaviti sistemsku uslugu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Ako zaustavite ovu uslugu, neke značajke vašeg tabletnog računala mogu prestati raditi ispravno dok ga ne isključite i ponovo ne uključite."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Ako zaustavite ovu uslugu, neke značajke vašeg telefona mogu prestati raditi ispravno dok ga ne isključite i ponovo ne uključite."</string>
    <string name="language_settings" msgid="5292716747264442359">"Jezik i ulaz"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Jezik i ulaz"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Postavke jezika"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tipkovnica i načini unosa"</string>
    <string name="phone_language" msgid="8870144109924299673">"Jezik"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automatska zamjena"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Ispravi pogrešno napisane riječi"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Automatsko pisanje velikih slova"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Postavi veliko slovo na početku rečenice"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automatsko stavljanje interpunkcije"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Postavke fizičke tipkovnice"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Pritisnite razmaknicu dvaput za umetanje \".\""</string>
    <string name="show_password" msgid="3001113966880559611">"Zaporke vidljive"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Ovaj način unosa možda može prikupljati sav tekst koji unosite, uključujući osobne podatke poput zaporki i brojeva kreditnih kartica. To omogućuje aplikacija <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Upotrijebiti taj način unosa?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ovaj alat za provjeru pravopisa može prikupljati sav tekst koji upisujete, uključujući osobne podatke kao što su zaporke i brojevi kreditnih kartica. Dolazi s aplikacije <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Upotrebljavati taj alat za provjeru pravopisa?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Postavke"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Jezik"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Otvaranje postavki za aplikaciju <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g> nije uspjelo"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Miš/dodirna površina"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Brzina pokazivača"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Upravljač igrama"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Upotrijebi vibrator"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Preusmjeri vibrator na upravljač igrama kada su povezani."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Odaberite izgled tipkovnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Postavljanje izgleda tipkovnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Za prijelaz pritisnite Ctrl i razmaknicu."</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Zadano"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Izgledi tipkovnice"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Osobni rječnik"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Dodaj u rječnik"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Više opcija"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Manje opcija"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"U redu"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Riječ:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Prečac:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Upišite riječ"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Neobavezni prečac"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Uredi riječ"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Uređivanje"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"Nemate nijednu riječ u korisničkom rječniku. Riječ možete dodati dodirom na gumb Dodaj (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Za sve jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Više jezika..."</string>
    <string name="testing" msgid="6584352735303604146">"Testiranje"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informacije o tabletnom uređaju"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Telefonske informacije"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Informacije o bateriji"</string>
    <string name="quick_launch_title" msgid="7904609846945905306">"Brzo pokretanje"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Postavljanje tipkovničkih prečaca za pokretanje aplikacija"</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Dodjela aplikacije"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Bez prečaca"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Pretraži + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Očisti"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Vaš prečac za stavku <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) bit će izbrisan."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"U redu"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Odustani"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Aplikacije"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Prečaci"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Unos teksta"</string>
    <string name="input_method" msgid="5434026103176856164">"Način ulaza"</string>
    <string name="choose_input_methods" msgid="3919825636585320942">"Odabir tipkovnica"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Trenutačna tipkovnica"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Selektor načina ulaza"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatski"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Uvijek prikaži"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Uvijek sakrij"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Postavljanje načina unosa"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Postavke"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Postavke"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktivni načini ulaza"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Upotrijebi jezik sustava"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"<xliff:g id="IME_NAME">%1$s</xliff:g> postavke"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Odabir aktivnih načina unosa"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Postavke zaslonske tipkovnice"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fizička tipkovnica"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Postavke fizičke tipkovnice"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Opcije za razvojne programere"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Postavljanje opcija za razvoj aplikacije"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Opcije razvojnih programera nisu dostupne za ovog korisnika"</string>
    <string name="vpn_settings_not_available" msgid="956841430176985598">"Postavke VPN-a nisu dostupne ovom korisniku"</string>
    <string name="tethering_settings_not_available" msgid="6765770438438291012">"Postavke dijeljenja veze nisu dostupne ovom korisniku"</string>
    <string name="apn_settings_not_available" msgid="7873729032165324000">"Postavke pristupne točke nisu dostupne ovom korisniku"</string>
    <string name="enable_adb" msgid="7982306934419797485">"Uklanjanje pogreške USB-a"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Uklanjanje pogrešaka s priključenim USB-om"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Opoziv autorizacija za uklanjanje pogrešaka USB-a"</string>
    <string name="bugreport_in_power" msgid="7923901846375587241">"Prečac izvješća o programskim pogreškama"</string>
    <string name="bugreport_in_power_summary" msgid="1778455732762984579">"Prikaži gumb u izborniku napajanja za izradu izvješća o programskim pogreškama"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Ne pokreći mirovanje"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Zaslon nikad neće prijeći u mirovanje tijekom punjenja"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Omogući zapisnik naredbe \"snoop\" za Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Snimi sve Bluetooth HCI pakete u datoteci"</string>
    <string name="oem_unlock_enable" msgid="6629321276287913315">"Omogući OEM otključavanje"</string>
    <string name="oem_unlock_enable_summary" msgid="3546686263996628110">"Dopuštanje OEM otključavanja uređaja"</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Certifikacija bežičnog prikaza"</string>
    <string name="wifi_verbose_logging" msgid="4203729756047242344">"Omogući opširnu prijavu na Wi-Fi"</string>
    <string name="wifi_aggressive_handover" msgid="9194078645887480917">"Aktivni prijelaz s Wi‑Fi na mob. mrežu"</string>
    <string name="wifi_allow_scan_with_traffic" msgid="3601853081178265786">"Uvijek dopusti slobodno traženje Wi-Fi mreže"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Prikaži opcije za certifikaciju bežičnog prikaza"</string>
    <string name="wifi_verbose_logging_summary" msgid="6615071616111731958">"Povećana razina prijave na Wi‑Fi, prikaz po SSID RSSI-ju u Biraču Wi‑Fi-ja"</string>
    <string name="wifi_aggressive_handover_summary" msgid="6328455667642570371">"Ako je omogućeno, Wi-Fi će aktivno prebacivati podatkovnu vezu mobilnoj mreži kada je Wi-Fi signal slab."</string>
    <string name="wifi_allow_scan_with_traffic_summary" msgid="2575101424972686310">"Dopuštanje/blokiranje slobodnog traženja Wi-Fi mreža na temelju količine podatkovnog prometa u sučelju"</string>
    <string name="select_logd_size_title" msgid="7433137108348553508">"Veličine međuspremnika zapisnika"</string>
    <string name="select_logd_size_dialog_title" msgid="1206769310236476760">"Odaberite veličinu međuspr. zapis."</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Dopusti probne lokacije"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Dopusti probne lokacije"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Omogućiti rješavanje programske pogreške na USB-u?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Rješavanje programske pogreške USB-a namijenjeno je samo u razvojne svrhe. Može se upotrijebiti za kopiranje podataka s računala na uređaj i obrnuto, instalaciju aplikacija na uređaju bez obavijesti i za čitanje dnevničkih zapisa."</string>
    <string name="adb_keys_warning_message" msgid="6932230298032192937">"Želite li opozvati pristup uklanjanju pogrešaka USB-a sa svih računala koja ste prethodno autorizirali?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Dopustiti postavke razvojnih programera?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Ove su postavke namijenjene samo razvojnim programerima. One mogu uzrokovati kvar ili neželjeno ponašanje vašeg uređaja i aplikacija na njemu."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Potvrdi aplikacije putem USB-a"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Provjerite uzrokuju li aplikacije instalirane putem ADB-a/ADT-a poteškoće."</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Zaštiti USB pohranu"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Aplikacije moraju tražiti dozvolu za čitanje USB pohrane"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Zaštititi USB pohranu?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Kad je USB pohrana zaštićena, aplikacije moraju tražiti dozvolu za čitanje podataka s vanjske pohrane.\n\nNeke aplikacije možda neće raditi dok ih razvojni programeri ne ažuriraju."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Zaštiti SD karticu"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Aplikacije moraju tražiti dozvolu za čitanje SD kartice"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Zaštititi SD karticu?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Kad je SD kartica zaštićena, aplikacije moraju tražiti dozvolu za čitanje podataka s vanjske pohrane.\n\nNeke aplikacije možda neće raditi dok ih razvojni programeri ne ažuriraju."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Lokalni terminal"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Omogući aplikaciju terminala koja nudi pristup lokalnoj ovojnici"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Odaberi gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Odaberite widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Želite izraditi widget i dozvoliti pristup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Kada izradite widget, aplikacija <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> može pristupiti svim podacima koje taj widget prikazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Uvijek dopusti aplikaciji <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> izradu widgeta i pristupanje njihovim podacima"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min <xliff:g id="SECONDS">%4$d</xliff:g> s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g>min <xliff:g id="SECONDS">%3$d</xliff:g> s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min"</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Korisnička statistika"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Korisnička statistika"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Poredati prema:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacija"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Posljednja upotreba"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Vrijeme upotrebe"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Dostupnost"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Postavke dostupnosti"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Usluge"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Sustav"</string>
    <string name="accessibility_display_title" msgid="7610175687949675162">"Zaslon"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Opisi"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Pokret povećavanja"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2380627654189671754">"Ako je ova značajka uključena, možete povećati ili smanjiti prikaz ako triput dodirnete zaslon.\n\nNakon povećanja prikaza možete sljedeće:\n"<ul><li>"Pomicati: pomoću dva prsta ili više prstiju povlačite prikaz na zaslonu."</li>\n<li>"Podesiti razinu zumiranja: stisnite dva prsta ili više prstiju ili ih raširite."</li></ul>\n\n"Također možete privremeno povećati stavku ispod prsta ako je triput dodirnete i držite. U tom slučaju možete povlačiti prst kako biste istražili različite dijelove zaslona. Podignite prst kako biste se vratili na prijašnje stanje.\n\nNapomena: povećanje trostrukim dodirom moguće je svuda osim na tipkovnici i traci za navigaciju."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Prečac pristupačnosti"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Uključeno"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Isključeno"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"Kada je ova značajka uključena, možete brzo omogućiti značajke pristupačnosti u dva koraka:\n\n1. korak: pritisnite i držite gumb za uključivanje/isključivanje dok ne začujete zvuk ili osjetite vibraciju.\n\n2. korak: dodirnite i držite s dva prsta dok ne začujete zvučnu potvrdu.\n\nAko uređaj ima više korisnika, ovaj prečac na zaključanom zaslonu omogućuje pristupačnost dok se uređaj ne otključa."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Veliki tekst"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Tekst s visokim kontrastom"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Uvećanje zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Autom. ažuriranje uvećanja zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Ažuriranje uvećanja zaslona pri izmjeni aplikacija"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Tipka za uključivanje prekida poziv"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Izgovori zaporke"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Dodirnite i držite odgodu"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inverzija boja"</string>
    <string name="accessibility_display_daltonizer_preference_title" msgid="4034958017657406631">"Ispravljanje prostora boja"</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Prikaži u Brzim postavkama"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Način ispravljanja"</string>
    <string name="daltonizer_type_overridden" msgid="3116947244410245916">"Premošćeno postavkom <xliff:g id="TITLE">%1$s</xliff:g>"</string>
    <string name="daltonizer_mode_disabled" msgid="7482661936053801862">"Onemogućeno"</string>
    <string name="daltonizer_mode_monochromacy" msgid="8485709880666106721">"Monokromatizam"</string>
    <string name="daltonizer_mode_deuteranomaly" msgid="5475532989673586329">"Deuteranomalija (crveno – zeleno)"</string>
    <string name="daltonizer_mode_protanomaly" msgid="8424148009038666065">"Protanomalija (crveno – zeleno)"</string>
    <string name="daltonizer_mode_tritanomaly" msgid="481725854987912389">"Tritanomalija (plavo – žuto)"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Postavke"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Uključeno"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Isključeno"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Pregled"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standardne opcije"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Jezik"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Veličina teksta"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Stil opisa"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Prilagođene opcije"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Boja pozadine"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Zasjenjenost pozadine"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Boja pozadine titlova"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Neprozirnost pozadine titlova"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Boja teksta"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Neprozirnost teksta"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Boja ruba"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Vrsta ruba"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Obitelj fonta"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Opisi će izgledati ovako"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Zadano"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Zadano"</string>
    <string name="color_none" msgid="3475640044925814795">"Ništa"</string>
    <string name="color_white" msgid="8045195170201590239">"Bijela"</string>
    <string name="color_gray" msgid="9192312087142726313">"Siva"</string>
    <string name="color_black" msgid="7517353520909872561">"Crna"</string>
    <string name="color_red" msgid="4949354900304125428">"Crvena"</string>
    <string name="color_green" msgid="5537717328428845841">"Zelena"</string>
    <string name="color_blue" msgid="7731984529016953223">"Plava"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cijan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Žuta"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Grimizna"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Želite li upotrijebiti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> treba obavljati sljedeće:"</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Praćenje vaših radnji"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="2095111008854376237">"Primajte obavijesti tijekom interakcije s aplikacijom."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Želite li zaustaviti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2012273739481042318">"Ako dodirnete \"U redu\", usluga <xliff:g id="SERVICE">%1$s</xliff:g> zaustavit će se."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nema instaliranih usluga"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nije dan opis."</string>
    <string name="settings_button" msgid="3006713718908152930">"Postavke"</string>
    <string name="print_settings" msgid="4742428530112487843">"Ispis"</string>
    <string name="print_settings_title" msgid="3685449667822217816">"Usluge ispisa"</string>
    <string name="print_service_security_warning_title" msgid="2338435517408144841">"Želite li upotrijebiti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="print_service_security_warning_summary" msgid="7567131958613064363">"Na putu do pisača vaš dokument može proći kroz jedan ili više poslužitelja."</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nema instaliranih usluga"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nije pronađen nijedan pisač"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Postavke"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Dodavanje pisača"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Uključeno"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Isključeno"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Dodaj uslugu"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Dodaj pisač"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Pretraži"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Traženje pisača"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Usluga je onemogućena"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Zadaci ispisa"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Zadatak ispisa"</string>
    <string name="print_restart" msgid="8373999687329384202">"Ponovo pokreni"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Odustani"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Ispisivanje zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Otkazivanje zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Pogreška pisača <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Pisač je blokirao <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Okvir za pretraživanje prikazan je"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Okvir za pretraživanje skriven je"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Baterija"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Što troši bateriju"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Podaci o iskorištenosti baterije nisu dostupni."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Preostalo je <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do dovršetka punjenja"</string>
    <string name="power_discharging" msgid="6023874912674684056">"<xliff:g id="LEVEL">%1$d</xliff:g>%%"</string>
    <string name="power_discharging_duration" msgid="7125493014448497620">"<xliff:g id="LEVEL">%1$d</xliff:g>%% – još približno <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="power_charging" msgid="712751285832976915">"<xliff:g id="LEVEL">%1$d</xliff:g>%% – <xliff:g id="STATE">%2$s</xliff:g>"</string>
    <string name="power_charging_duration" msgid="4802183864773082009">"<xliff:g id="LEVEL">%1$d</xliff:g>%% – <xliff:g id="TIME">%2$s</xliff:g> do napunjenosti"</string>
    <string name="power_charging_duration_ac" msgid="3611179931297824699">"<xliff:g id="LEVEL">%1$d</xliff:g>%% – <xliff:g id="TIME">%2$s</xliff:g> do napunjenosti putem utičnice"</string>
    <string name="power_charging_duration_usb" msgid="1106605348913397583">"<xliff:g id="LEVEL">%1$d</xliff:g>%% – <xliff:g id="TIME">%2$s</xliff:g> do napunjenosti putem USB-a"</string>
    <string name="power_charging_duration_wireless" msgid="633606920144617227">"<xliff:g id="LEVEL">%1$d</xliff:g>%% – <xliff:g id="TIME">%2$s</xliff:g> do napunjenosti bežičnim putem"</string>
    <string name="power_usage_list_summary" msgid="2409288197839512482">"Upotreba od posljednje napunjenosti"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Upotreba baterije nakon isključivanja"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Upotreba baterije od poništavanja"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> na bateriji"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od isključivanja"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Punjenje"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Zaslon uključen"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS uključen"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Budan"</string>
    <string name="battery_stats_phone_signal_label" msgid="3537569115723850618">"Signal mobilne mreže"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Vrijeme budnosti uređaja"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Wi-Fi na vrijeme"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Wi-Fi na vrijeme"</string>
    <string name="usage_name_percent" msgid="7976919382448235858">"<xliff:g id="NAME">%1$s</xliff:g> - <xliff:g id="NUMBER">%2$s</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Detalji povijesti"</string>
    <string name="details_title" msgid="3792801565213935385">"Pojedinosti o upotrebi"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Pojedinosti o upotrebi"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Podesi potrošnju energije"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Uključeni paketi"</string>
    <string name="power_screen" msgid="3023346080675904613">"Zaslon"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Bljeskalica"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Način čekanja"</string>
    <string name="power_phone" msgid="5392641106474567277">"Glasovni pozivi"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tabletni uređaj u mirovanju"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon u mirovanju"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Razno"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Previše obračunato"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Ukupno CPU-a"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"Glavni zadatak CPU-a"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Zadrži u aktivnom stanju"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi se izvodi"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tabletni uređaj"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Poslani mobilni paketi"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Primljeni mobilni paketi"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Mobilni je radio aktivan"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Poslani Wi‑Fi paketi"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Primljeni Wi‑Fi paketi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Videozapis"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Vrijeme uključenosti"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Vrijeme bez signala"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Ukupan kapacitet baterije"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Obračunata potrošnja energije"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Izmjerena potrošnja energije"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Prisilno zaustavi"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informacije o aplikaciji"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Postavke aplikacije"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Postavke zaslona"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Postavke Wi-Fi-ja"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Bluetooth postavke"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Baterija upotrijebljena uslugom glasovnog poziva"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Upotreba baterije kad je tabletni uređaj u mirovanju"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Upotreba baterije tijekom mirovanja telefona"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Baterija iskorištena upotrebom radija"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Prebacite se na način rada u zrakoplovu u područjima loše pokrivenosti signalom da biste uštedjeli energiju"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Potrošnja baterije za bljeskalicu"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Baterija se koristi za prikaz i pozadinsko svjetlo"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Smanjite svjetlinu i/ili vrijeme čekanja zaslona"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Baterijom se služi Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="3355461362094706957">"Isključi Wi-Fi ako se ne upotrebljava ili ako nije dostupan"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Baterija iskorištena upotrebom značajke Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Isključite Bluetooth ako ga ne upotrebljavate"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Pokušajte se povezati s drugim Bluetooth uređajem"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Baterija iskorištena upotrebom aplikacija"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Zaustavite ili deinstalirajte aplikaciju"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Odaberite način štednje baterije"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacija možda nudi postavke za smanjenje potrošnje baterije"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Baterija koju upotrebljava korisnik"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Potrošnja energije u razne svrhe"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Upotreba baterije procjena je potrošnje energije i ne uključuje sve izvore potrošnje baterije. Vrijednost \"razno\" odnosi se na razliku između obračunate procijenjene potrošnje energije i stvarne potrošnje izmjerene na bateriji."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Previše obračunata potrošnja energije"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od isključivanja"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Kod posljednjeg isključivanja za <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Ukupno iskorištenje"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Osvježi"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Android OS"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Medijski poslužitelj"</string>
    <string name="battery_saver" msgid="1426682272004907982">"Štednja baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Uključi automatski"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikada"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="3033681629861428940">"pri %1$d%% baterije"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistički podaci o procesima"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Detaljni statistički podaci o trenutačnim procesima"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Upotreba memorije"</string>
    <string name="process_stats_total_duration" msgid="1869761515101180444">"<xliff:g id="TYPE">%1$s</xliff:g> aplikacije tijekom <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Pozadina"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Prednji plan"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Spremljeno u privremenu memoriju"</string>
    <string name="process_stats_memory_status" msgid="4251599550196193093">"Memorija uređaja trenutačno je <xliff:g id="MEMSTATE">%1$s</xliff:g>"</string>
    <string name="process_stats_avg_ram_use" msgid="6972943528929394396">"Prosječna upotreba RAM-a"</string>
    <string name="process_stats_max_ram_use" msgid="3273876448926689261">"Maksimalna upotreba RAM-a"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Vrijeme izvođenja"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Usluge"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Trajanje"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Informacije o memoriji"</string>
    <string name="mem_state_subtitle" msgid="2407238869781011933">"Stanja memorije"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Upotreba memorije"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Jezgra sustava"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Nativni procesi"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Predmemorije jezgre sustava"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"Prijelaz na ZRam"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"Dostupna"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Ukupno"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 sata"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 sati"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 sati"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 dan"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Prikaži sustav"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Upotrijebi USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Vrsta statističkih podataka"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Pozadina"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Prednji plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Spremljeno u privremenu memoriju"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Glas. ulaz i izlaz"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Postavke za glasovni unos i izlazne vrijednosti"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Glasovno pretraživanje"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Android tipkovnica"</string>
    <string name="voice_category" msgid="1430370497125803904">"Govor"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Postavke glasovnog unosa"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Glasovni unos"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Usluge glasovnog unosa"</string>
    <string name="voice_interactor_preference_summary" msgid="5995613396290979463">"Potpuna glasovna interakcija"</string>
    <string name="voice_recognizer_preference_summary" msgid="878040238053901752">"Jednostavno prepoznavanje glasa"</string>
    <string name="voice_interaction_security_warning" msgid="1272774555442633823">"Ova usluga glasovnog unosa moći će kontrolirati sve aplikacije s omogućenim glasovnim značajkama u vaše ime. Pripada aplikaciji <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Želite li omogućiti njezinu upotrebu?"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Postavke za tekst u govor"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Izlaz pretvaranja teksta u govor"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Uvijek koristi moje postavke"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Donje zadane postavke poništavaju postavke aplikacije"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Zadane postavke"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Zadani alat"</string>
    <string name="tts_default_synth_summary" msgid="6482936537135251690">"Postavlja alat za sintezu govora za upotrebu u izgovorenom tekstu"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Brzina govora"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Brzina kojom se izgovara tekst"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Visina glasa"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Utječe na ton izgovorenog teksta"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Jezik"</string>
    <string name="tts_lang_use_system" msgid="2679252467416513208">"Upotrijebi jezik sustava"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Jezik nije odabran"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Postavlja jezik govora"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Poslušajte primjer"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Poslušajte primjer sinteze zvuka"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Instaliraj glasovne podatke"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Instaliraj glasovne podatke potrebne za sintezu govora"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Glasovi potrebni za sintezu govora već su ispravno instalirani"</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Vaše su postavke promijenjene. Ovo je primjer kako zvuče."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Alat koji ste odabrali ne može se pokrenuti."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Konfiguriraj"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Odaberite drugi alat"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Alat za sintezu govora može prikupljati izgovoreni sadržaj, uključujući osobne podatke kao što su zaporke i brojevi kreditnih kartica. To omogućuje alat <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Želite li omogućiti alat za sintezu govora?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"Da bi se dobili izlazni podaci pretvaranja teksta u govor za taj jezik, potrebna je aktivna veza s mrežom."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"Ovo je primjer sinteze govora"</string>
    <string name="tts_status_title" msgid="7268566550242584413">"Status zadanog jezika"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"<xliff:g id="LOCALE">%1$s</xliff:g> je u potpunosti podržan"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"<xliff:g id="LOCALE">%1$s</xliff:g> zahtijeva mrežnu vezu"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"<xliff:g id="LOCALE">%1$s</xliff:g> nije podržan"</string>
    <string name="tts_status_checking" msgid="4983413982985913047">"Provjera..."</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Alati"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> postavke"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"Stavka <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je onemogućena"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"Stavka <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je onemogućena"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Postavke tražilice"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Postavke za <xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Jezici i glasovi"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Instalirano"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Nije instalirano"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Žena"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Muškarac"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Stroj za sintezu govora uključen"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Omogući alat prije upotrebe"</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Postavke pokretanja alata"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Željeni alat"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Opće"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Nadzor nad napajanjem"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Ažuriranje Wi-Fi postavki"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Ažuriranje postavke Bluetootha"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"uključeno"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"isključeno"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"uključivanje"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"isključivanje"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Lokacija"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sinkronizacija"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Svjetlina <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automatski"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"potpuna"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"polovična"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"isključena"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Pohrana vjerodajnica"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instaliraj iz memorije"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instaliraj s kartice SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Instaliraj certifikate iz memorije"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Instaliraj certifikate s kartice SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Izbriši vjerodajnice"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Uklanjanje svih certifikata"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Pouzdane vjerodajnice"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Prikaz pouzdanih CA certifikata"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Napredno"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Vrsta pohrane"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Hardverska"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Samo softverska"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Za ovog korisnika nisu dostupne vjerodajnice"</string>
    <string name="credentials_install_gesture_prompt" msgid="2207390278112395082">"Iscrtajte obrazac za otključavanje"</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Da biste potvrdili instalaciju vjerodajnica, trebate nacrtati svoj obrazac za otključavanje."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Upišite zaporku za pohranu vjerodajnica."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Trenutačna zaporka:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Ukloniti sve sadržaje?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Zaporka treba imati barem 8 znakova."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Pogrešna zaporka."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Pogrešna zaporka. Imate još jedan pokušaj prije brisanja pohrane vjerodajnica."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Pogrešna zaporka. Još imate ovoliko pokušaja prije brisanja pohrane vjerodajnica: <xliff:g id="NUMBER">%1$d</xliff:g>."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Pohrana vjerodajnica izbrisana je."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Pohrana vjer. nije izbrisana."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Pohranjivanje vjerodajnica je omogućeno."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Trebate postaviti PIN ili zaporku za zaključavanje zaslona prije nego što ćete moći upotrebljavati pohranu vjerodajnica."</string>
    <string name="usage_access_title" msgid="7486234618012778690">"Pristup upotrebi"</string>
    <string name="usage_access_summary" msgid="5393473213889000980">"Aplikacije koje mogu pristupati povijesti upotrebe uređaja."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Ton hitnog poziva"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Postavite način ponašanja za hitan poziv"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Stvori sigurnosnu kopiju i poništi"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Stvori sigurnosnu kopiju i poništi"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Sigurnosna kopija i vraćanje"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Osobni podaci"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Stvori sigurnosnu kopiju mojih podataka"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Stvaranje sigurnosne kopije podataka aplikacije, Wi-Fi zaporki i ostalih postavki na Googleovim poslužiteljima"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Sigurnosni račun"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Nijedan račun trenutno ne stvara sigurnosne kopije podataka"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Uključi podatke aplikacija"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automatska obnova"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Pri ponovnoj instalaciji aplikacije vratiti postavke i podatke za koje su stvorene sigurnosne kopije"</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Zaporka sigurnosne kopije"</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"Potpune sigurnosne kopije na stolnom računalu trenutačno nisu zaštićene"</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Odaberite za promjenu ili uklanjanje zaporke u potpunim sigurnosnim kopijama na stolnom računalu"</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Nova pričuvna zaporka postavljena"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Nova zaporka i potvrda ne odgovaraju"</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Nije uspjelo postavljanje pričuvne zaporke"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Želite li zaustaviti stvaranje sigurnosnih kopija Wi-Fi zaporki, oznaka, drugih postavki i podataka aplikacije te izbrisati sve kopije na Googleovim poslužiteljima?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Postavke administracije uređaja"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Administrator uređaja"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Deaktiviraj"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Administratori uređaja"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Nema dostupnih administratora računa"</string>
    <string name="managed_profile_device_admin_info" msgid="6105994454581829513">"Da apl. <xliff:g id="APP_NAME">%1$s</xliff:g> ne bi pristupala radnom profilu, uklonite ga (Postavke &gt; Računi)."</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Osobno"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Posao"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Pouzdani predstavnici nisu dostupni"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Aktivirati administratora uređaja?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Aktiviraj"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Administrator uređaja"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Aktiviranjem ovog administratora dopustit ćete aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvede sljedeće postupke:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Ovaj je administrator aktivan i aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> dopušta izvođenje sljedećih postupaka:"</string>
    <string name="profile_owner_add_title" msgid="1127236753400079839">"Vlasnik profila"</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Bez naslova"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Općenito"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Zapisnik obavijesti"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Melodija zvona i vibriranje za poziv"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Sustav"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Postavljanje Wi-Fi mreže"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Povezivanje s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Povezivanje s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>…"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Povezano s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Dodavanje mreže"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Nije povezan"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Dodaj mrežu"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Osvježi popis"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Preskoči"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Dalje"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Natrag"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Detalji mreže"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Poveži"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Zaboravi"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Spremi"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Odustani"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Skeniranje mreža…"</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Dodirnite mrežu da biste se povezali s njom"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Spoji s postojećom mrežom"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Pov. s nesigurnom mrežom"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Upišite konfiguraciju mreže"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Spoji s novom mrežom"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Povezivanje…"</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Idite na sljedeći korak"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"EAP nije podržan."</string>
    <string name="wifi_setup_eap_not_supported" msgid="1955087534276570962">"Ne možete konfigurirati EAP Wi-Fi vezu tijekom postavljanja. To možete učiniti nakon postavljanja u Postavkama pod stavkom Bežično povezivanje i mreže."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Povezivanje može potrajati nekoliko minuta..."</string>
    <string name="wifi_setup_description_connected" msgid="736032046548460779">"Dodirnite "<b>"Dalje"</b>" za nastavak postavljanja.\n\nDodirnite "<b>"Natrag"</b>" za povezivanje s nekom drugom Wi-Fi mrežom."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinkronizacija je omogućena"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Onemogućena je sinkronizacija"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Sinkronizacija u tijeku"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Pogreška sinkronizacije"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinkronizacija nije uspjela"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinkronizacija aktivna"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinkronizacija"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sinkronizacija trenutačno ima problema. Uskoro će nastaviti s radom."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Dodavanje računa"</string>
    <!-- no translation found for managed_profile_not_available_label (5113461928275887768) -->
    <skip />
    <!-- no translation found for remove_managed_profile_label (3856519337797285325) -->
    <skip />
    <string name="background_data" msgid="5779592891375473817">"Pozadinski podaci"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacije mogu sink., slati i primati podatke bilo kad"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Onem. poz. podatke?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Onemogućavanje pozadinskih podataka produljuje trajanje baterije i smanjuje upotrebu podataka. Neke aplikacije još uvijek mogu upotrebljavati pozadinsku podatkovnu vezu."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Automat. sink. podataka aplikacije"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sink. uključena"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sink. ISKLJUČENA"</string>
    <string name="sync_error" msgid="5060969083117872149">"Pogreška sink."</string>
    <string name="last_synced" msgid="4242919465367022234">"Zadnja sinkronizacija: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sinkronizacija u tijeku…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Postavke sigurnosne kopije"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Stvori sigurnosnu kopiju postavki"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinkroniziraj sada"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Otkaži sinkronizaciju"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Dodirnite da biste odmah sinkronizirali<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendar"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontakti"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Dobro došli u Googleovu sinkronizaciju!"</font>\n"Googleov pristup sinkronizaciji podataka za mogućnost pristupa kontaktima, sastancima i drugim stavkama s bilo kojeg mjesta."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Postavke sinkronizacije aplikacije"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Podaci i sinkronizacija"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Promijeni zaporku"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Postavke računa"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Brisanje računa"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Dodavanje računa"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Završi"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Ukloniti račun?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Uklanjanjem ovog računa izbrisat će se sve njegove poruke, kontakti i ostali podaci s tabletnog računala!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Uklanjanjem ovog računa izbrisat će se sve njegove poruke, kontakti i ostali podaci s telefona!"</string>
    <string name="remove_account_failed" msgid="4010643669489606536">"Vaš administrator ne dopušta tu promjenu"</string>
    <string name="provider_label" msgid="7724593781904508866">"Pokreni pretplate"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Nije moguća ručna sinkronizacija"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Sinkronizacija za tu stavku trenutačno je onemogućena. Da biste promijenili tu postavku, privremeno uključite pozadinske podatke i automatsku sinkronizaciju."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"4G MAC adresa"</string>
    <string name="enter_password" msgid="4131758584074246224">"Unesite zaporku za dešifriranje pohrane"</string>
    <string name="enter_pin" msgid="286221169871526876">"Unesite PIN za dekriptiranje pohrane"</string>
    <string name="enter_pattern" msgid="5707838886272453608">"Nacrtajte uzorak za dekriptiranje pohrane"</string>
    <string name="try_again" msgid="4272075051293936921">"Pokušajte ponovo."</string>
    <string name="delete" msgid="4219243412325163003">"Izbriši"</string>
    <string name="misc_files" msgid="6720680815969643497">"Razne datoteke"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"odabrano <xliff:g id="NUMBER">%1$d</xliff:g> od <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Odaberi sve"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"HDCP provjera"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Postav. ponaš. HDCP prov."</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Uklanjanje pogrešaka"</string>
    <string name="debug_app" msgid="8349591734751384446">"Odaberite aplikaciju za uklanjanje pogrešaka"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Nema aplikacije za uklanjanje pogrešaka"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Aplikacija za uklanjanje pogrešaka: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Odaberite aplikaciju"</string>
    <string name="no_application" msgid="2813387563129153880">"Ništa"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Čekanje na program za otkrivanje pogrešaka"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Aplikacija čeka priključivanje programa za uklanjanje pogrešaka"</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Ulaz"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Crtež"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Hardverski ubrzano renderiranje"</string>
    <string name="media_category" msgid="4388305075496848353">"Mediji"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Nadzor"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Omogućen strogi način"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Flash zaslon kada aplikacije na glavnoj niti izvršavaju duge operacije"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Mjesto pokazivača"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Prekrivanje zaslona prikazuje trenutačne podatke o dodirivanju"</string>
    <string name="show_touches" msgid="1356420386500834339">"Prikaži dodire"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Prikaži vizualne povratne informacije za dodire"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Prikaži ažur. površine"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Bljeskanje cijele površine prozora pri ažuriranju"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Prikaži GPU ažur. prikaza"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Bljeskanje prikaza u prozorima pri crtanju GPU-om"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Prikaži ažuriranja hardverskih slojeva"</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Neka hardverski slojevi bljeskaju zeleno kad se ažuriraju"</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Ukl. pogr. GPU sl. iscrt."</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Onemogući HW preklapanja"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Uvijek upotrijebi GPU kod slaganja zaslona"</string>
    <string name="simulate_color_space" msgid="6745847141353345872">"Simuliraj prostor boja"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Omogući OpenGL praćenja"</string>
    <string name="use_nuplayer" msgid="5699257393367904387">"Koristi NuPlayer (eksp.)"</string>
    <string name="use_nuplayer_summary" msgid="1991479067478516714">"Koristi NuPlayer umjesto AwesomePlayera"</string>
    <string name="usb_audio_disable_routing" msgid="8114498436003102671">"Onemogući USB audiousmj."</string>
    <string name="usb_audio_disable_routing_summary" msgid="980282760277312264">"Onemogući aut. usmjeravanje na USB audioperiferiju"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Prikaži granice izgleda"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Za isječak prikaži granice, margine itd."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Nametni zdesna ulijevo"</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Nametni smjer zdesna ulijevo za sve zemlje/jezike"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Prikaži upotrebu procesora"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Prekrivanje zaslona prikazuje trenutačnu upotrebu procesora"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Prisilno GPU renderiranje"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Prisilna upotreba GPU-a za 2D crteže"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Nametni 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Omogući 4x MSAA u aplikacijama OpenGL ES 2.0"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Otkloni pogreške operacija nepravokutnog isječka"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profil GPU prikazivanja"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Razmjer animacije prozora"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Animacija prijelaza razmjera"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Razmjer duljine animatora"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Simuliraj sekund. zaslone"</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Aplikacije"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Uklanjanje aktivnosti"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Uništite svaku aktivnost čim je korisnik napusti"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Ograničenje pozadinskog procesa"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Prikaži sve ANR-ove"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Prikaz dijaloga o pozad. aplik. koja ne odgovara"</string>
    <string name="webview_data_reduction_proxy" msgid="9184006980398676807">"Smanjenje upotr. mreže za WebView"</string>
    <string name="webview_data_reduction_proxy_summary" msgid="4743441353857190066">"Smanjenje upotrebe mreže za veze s proxyjem WebView putem Googleovih poslužitelja za komprimiranje (eksperimentalno)"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Potrošnja podataka"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Upotreba podataka za apl."</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Mobilni operater može obračunavati podatke na drugačiji način od uređaja."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Upotreba za aplikacije"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFORMACIJE O APLIKACIJAMA"</string>
    <string name="data_usage_cellular_data" msgid="4859424346276043677">"Mobilni podaci"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Postavljanje ograničenja podataka"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Ciklus upotrebe podataka"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Upotreba za aplikacije"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Roaming podataka"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Ograničenje pozadinskih podataka"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Dopusti pozadinske podatke"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Zasebna upotreba mreže 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Pokaži Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Sakrij Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Prikaži Ethernet upotrebu"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Sakrij upotrebu etherneta"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Mrežna ograničenja"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatska sinkronizacija podataka"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"SIM kartice"</string>
    <string name="data_usage_menu_cellular_networks" msgid="5243515735055652279">"Mobilne mreže"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Automat. sinkroniziraj podatke"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Aut. sinkroniz. osobne podatke"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Aut. sinkroniz. radne podatke"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Promjena ciklusa..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Dan u mjesecu za poništavanje ciklusa upotrebe podataka:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"U tom razdoblju aplik. nisu upotreblj. podatke."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Prednji plan"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Pozadina"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"ograničeno"</string>
    <string name="data_usage_disable_mobile" msgid="2613595056882494652">"Želite li isključiti mobilne podatke?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="3934211003105066167">"Ograniči mobilne podatke"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Postavi ograničenje za 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Postavi ograničenje za 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Ograniči podatke za Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="2084466270343460491">"Mobilno"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="7219011330831181312">"Mobilno"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Ništa"</string>
    <string name="data_usage_enable_mobile" msgid="5900650720568852325">"Mobilni podaci"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"2G-3G podaci"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"4G podaci"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Prednji plan:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Pozadina:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Postavke aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="7510046552380574925">"Ograniči pozadinske podatke apl."</string>
    <string name="data_usage_app_restrict_background_summary" msgid="3720075732277934106">"Onemogući pozadinske podatke na mobilnim mrežama."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="1446565717342917727">"Za ograničenje pozad. podataka za apl. ograničite mob. podatke."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Ograničenje pozadinskih podataka?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5871168521456832764">"Zbog te značajke aplikacija koja ovisi o pozadinskim podacima može prestati raditi kada su dostupne samo mobilne mreže.\n\nU postavkama koje su dostupne u aplikaciji možete naći prikladnije kontrole prijenosa podataka."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="4674085030810350875">"Ograničavanje pozadinskih podataka moguće je samo ako ste postavili ograničenje mobilnih podataka."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Uključiti auto. sinkronizaciju?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Promjene računa koje unesete na webu automatski će se kopirati na tablet.\n\nNeki računi također mogu automatski kopirati promjene s tableta na web. Google račun funkcionira na taj način."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Promjene računa koje unesete na webu automatski će se kopirati na telefon.\n\nNeki računi također mogu automatski kopirati promjene s telefona na web. Google račun funkcionira na taj način."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Isključiti auto. sinkronizaciju?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"Time će se uštedjeti promet podataka i potrošnja baterije, ali svaki ćete račun morati ručno sinkronizirati kako biste dobili najnovije informacije. Nećete primati obavijesti o ažuriranjima."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Datum poništavanja ciklusa upotrebe"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Datum svakog mjeseca."</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Postavi"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Postavite upozorenje o upotrebi podataka"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Postavite ograničenje upotrebe podataka"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Ograničavanje upotrebe podataka"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="5788774061143636263">"Tablet će isključiti mobilne podatke kada dosegne ograničenje koje ste postavili.\n\nBudući da potrošnju podataka mjeri tablet i da se obračun mobilnog operatera može razlikovati, možda biste trebali postaviti strože ograničenje."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3511301596446820549">"Telefon će isključiti mobilne podatke kada dosegne ograničenje koje ste postavili.\n\nBudući da potrošnju podataka mjeri telefon i da se obračun mobilnog operatera može razlikovati, možda biste trebali postaviti strože ograničenje."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Ograničenje pozadinskih podataka?"</string>
    <string name="data_usage_restrict_background" msgid="8210134218644196511">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge funkcionirat će samo ako se povežete s Wi‑Fi mrežom."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="3262993384666280985">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge funkcionirat će samo ako se povežete s Wi‑Fi mrežom.\n\nTa postavka utječe na sve korisnike tableta."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="4352615206362479722">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge funkcionirat će samo ako se povežete s Wi‑Fi mrežom.\n\nTa postavka utječe na sve korisnike telefona."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="21">"Upozorenja: <xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12"></font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"ograničenje"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Uklonjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Uklonjene aplikacije i korisnici"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"Primljeno: <xliff:g id="RECEIVED">%1$s</xliff:g>, poslano: <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: upotrijebljeno otprilike <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="5961720793603268572">"<xliff:g id="RANGE">%2$s</xliff:g>: upotrijebljeno oko <xliff:g id="TOTAL">%1$s</xliff:g>, prema mjerenju tableta. Operater može mjeriti drukčije."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="1625833170144610767">"<xliff:g id="RANGE">%2$s</xliff:g>: upotrijebljeno oko <xliff:g id="TOTAL">%1$s</xliff:g>, prema mjerenju telefona. Operater može mjeriti drukčije."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Mrežna ograničenja"</string>
    <string name="data_usage_metered_body" msgid="3262343834446126044">"Mreže s naplatom tretiraju se kao mobilne mreže kada su pozadinski podaci ograničeni. Aplikacije mogu upozoriti prije upotrebe tih mreža za velika preuzimanja."</string>
    <string name="data_usage_metered_mobile" msgid="2326986339431119372">"Mobilne mreže"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Wi-Fi mreže s naplatom"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Da biste odabrali mreže s naplatom, uključite Wi‑Fi."</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Mobilni operater može obračunavati podatke na drugačiji način od uređaja."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Hitan poziv"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Vrati se na poziv"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Naziv"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Vrsta"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa poslužitelja"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"PPP enkripcija (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"tajna L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"IPSec identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"IPSec unaprijed dijeljeni ključ"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"IPSec korisnički certifikat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"IPSec CA certifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"IPSec certifikat poslužitelja"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Prikaži napredne opcije"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domene DNS pretraživanja"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"DNS poslužitelji (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Prosljeđivanje ruta (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Korisničko ime"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Zaporka"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Spremi podatke o računu"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nije upotrijebljeno)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(ne potvrđuj poslužitelja)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(primljen od poslužitelja)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Odustani"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Spremi"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Poveži"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Uređivanje VPN profila"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Povezivanje s profilom <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Dodavanje VPN profila"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Uredi profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Izbriši profil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Uvijek uključena VPN mreža"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Odaberite VPN profil s kojim ćete uvijek biti povezani. Mrežni promet bit će dopušten samo kada ste povezani s tom VPN mrežom."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Ništa"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Uvijek uključena VPN mreža zahtijeva IP adresu za poslužitelj i za DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Nema mrežne veze. Pokušajte ponovo kasnije."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Nedostaje certifikat. Uredite profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sustav"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Korisnik"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Onemogući"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Omogući"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Ukloni"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Želite li omogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Želite li onemogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Želite li trajno ukloniti korisnički CA certifikat?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Provjera pravopisa"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Ovdje unesite trenutačnu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Ovdje upišite novu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Ovdje ponovo unesite novu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Postavi zaporku za sigurnosnu kopiju"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Odustani"</string>
    <string name="percentage" msgid="5866131581207788624">"<xliff:g id="NUMBER">%d</xliff:g>%%"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Dodatna ažuriranja sustava"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Onemogućeno"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Omogućeno"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Provođenje"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Mreža se možda nadzire"</string>
    <string name="done_button" msgid="1991471253042622230">"Završeno"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="5339377665264149395">"Nadzor mreže"</string>
    <string name="ssl_ca_cert_info_message" msgid="4583879256548819713">"Tim uređajem upravlja:\n<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>\n\nVaš administrator može nadzirati vaše aktivnosti na mreži, uključujući e-poštu, aplikacije i sigurne web-lokacije.\n\nZa više informacija obratite se svom administratoru."</string>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Treća je strana u mogućnosti pratiti vašu mrežnu aktivnost, uključujući e-poštu, aplikacije i sigurne web-lokacije.\n\nTo omogućuje pouzdana vjerodajnica koja je instalirana na vašem uređaju."</string>
    <string name="ssl_ca_cert_settings_button" msgid="8760495070836213605">"Provjeri pouzdane vjerodajnice"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Korisnici"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Korisnici i profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Dodavanje korisnika ili profila"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Dodaj korisnika"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Ograničeni profil"</string>
    <string name="user_summary_managed_profile" msgid="5729429961989469287">"Upravljani profil"</string>
    <string name="user_need_lock_message" msgid="2596365678651842785">"Prije izrade ograničenog profila trebate postaviti zaključavanje zaslona radi zaštite svojih aplikacija i osobnih podataka."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Postavi zaključavanje"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nije postavljen"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Nije postavljen – ograničeni profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="8571841525128790750">"Nije postavljen – upravljani profil"</string>
    <string name="user_owner" msgid="3879126011135546571">"Vlasnik"</string>
    <string name="user_you" msgid="1639158809315025986">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Nadimak"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Dodavanje"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Korisnici imaju vlastite aplikacije i sadržaj"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Možete ograničiti pristup aplikacijama i sadržaju sa svojeg računa"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Korisnik"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Ograničeni profil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Dodati novog korisnika?"</string>
    <string name="user_add_user_message_long" msgid="718192651887726259">"Za dijeljenje ovog uređaja s drugima možete izraditi dodatne korisnike. Svaki korisnik ima vlastiti prostor koji može prilagoditi pomoću vlastitih aplikacija, pozadinske slike i tako dalje. Korisnici mogu prilagoditi i postavke uređaja koje utječu na sve ostale korisnike, na primjer, Wi‑Fi.\n\nKada dodate novog korisnika, ta osoba mora postaviti svoj prostor.\n\nBilo koji korisnik može ažurirati aplikacije za sve ostale korisnike."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Kada dodate novog korisnika, ta osoba mora postaviti vlastiti prostor.\n\nBilo koji korisnik može ažurirati aplikacije za sve ostale korisnike."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Postaviti korisnika sada?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Provjerite može li osoba uzeti uređaj i postaviti svoj prostor"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Želite li sada postaviti profil?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Postavi sada"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Ne sad"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="8440449301994432789">"Samo vlasnik tabletnog računala može upravljati korisnicima."</string>
    <string name="user_cannot_manage_message" product="default" msgid="1133251987818014757">"Samo vlasnik telefona može upravljati korisnicima."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Ograničeni profili ne mogu dodavati račune"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"<xliff:g id="USER_NAME">%1$s</xliff:g>: brisanje s uređaja"</string>
    <string name="user_add_on_lockscreen_menu" msgid="3025132738715222247">"Dodaj korisnike na zaključani uređaj"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Novi korisnik"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Novi profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Ukloniti korisnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Ukloniti profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="8167855311779740207">"Izgubit ćete svoj prostor i podatke na ovom tabletnom računalu. Ta se radnja ne može poništiti."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5391888073786090274">"Izgubit ćete svoj prostor i podatke na ovom telefonu. Ta se radnja ne može poništiti."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Izbrisat će se sve aplikacije i podaci."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Izbrisat će se sve aplikacije i podaci."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Dodavanje novog korisnika…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Izbriši korisnika"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Izbriši"</string>
    <string name="user_guest" msgid="8475274842845401871">"Gost"</string>
    <string name="user_exit_guest_title" msgid="45738573948463472">"Izlaz iz gostujuće sesije"</string>
    <string name="user_exit_guest_confirm_title" msgid="2512294416196448006">"Želite li napustiti gostujuću sesiju?"</string>
    <string name="user_exit_guest_confirm_message" msgid="3338292192386196163">"Prekidanjem gostujuće sesije uklonit će se lokalni podaci."</string>
    <string name="user_enable_calling" msgid="8310589470979488255">"Dopusti telefonske pozive"</string>
    <string name="user_enable_calling_sms" msgid="794823380737672333">"Dopusti telefonske pozive i SMS"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Ukloni korisnika"</string>
    <string name="user_enable_calling_confirm_title" msgid="440218975766968124">"Želite li dopustiti telefonske pozive?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Povijest poziva dijelit će se s tim korisnikom."</string>
    <string name="user_enable_calling_sms_confirm_title" msgid="188164598768941316">"Želite li dopustiti telefonske pozive i SMS?"</string>
    <string name="user_enable_calling_sms_confirm_message" msgid="9101983352082865696">"Povijest poziva i SMS-ova dijelit će se s tim korisnikom."</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Dopuštanje aplikacija i sadržaja"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikacije s ograničenjima"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Proširi postavke za aplikaciju"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Deinstaliraj aplikaciju"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Postavke početnog zaslona bit će skrivene dok ne instalirate još jednu aplikaciju početnog zaslona."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Ova postavka utječe na sve korisnike na ovom tabletu."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Ova postavka utječe na sve korisnike na ovom telefonu."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Promjena jezika"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Promjena veličine fonta"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Dodirni i plati"</string>
    <string name="google_wallet" msgid="9122936252378589227">"Google novčanik"</string>
    <string name="nfc_payment_no_apps" msgid="2481080809791416010">"Platite samo jednim dodirom"</string>
    <string name="nfc_payment_favor_foreground" msgid="8881893980929835838">"Daj prednost aplikaciji u prednjem planu"</string>
    <string name="nfc_payment_learn_more" msgid="5583407773744324447">"Saznajte više"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Više..."</string>
    <string name="nfc_payment_menu_item_add_service" msgid="2885947408068969081">"Traženje aplikacija"</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Želite li to postaviti kao željeni način?"</string>
    <string name="nfc_payment_set_default" msgid="8961120988148253016">"Uvijek upotrijebiti aplikaciju <xliff:g id="APP">%1$s</xliff:g> za opciju Dodirni i plati?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="3803693771001226795">"Uvijek upotrijebiti aplikaciju <xliff:g id="APP_0">%1$s</xliff:g> umjesto aplikacije <xliff:g id="APP_1">%2$s</xliff:g> za opciju Dodirni i plati?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Ograničenja"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Uklanjanje ograničenja"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Promjena PIN-a"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Prikaži obavijesti"</string>
    <string name="help_label" msgid="6886837949306318591">"Pomoć/povratne inf."</string>
    <string name="user_account_title" msgid="1127193807312271167">"Račun za sadržaj"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografije"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Ekstremne prijetnje"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Primanje upozorenja za ekstremne prijetnje po život/imovinu"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Ozbiljne prijetnje"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Primanje upozorenja za ozbiljne prijetnje po život i imovinu"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"AMBER upozorenja"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Primanje biltena o otmicama djece"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Ponovi"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Omogući Upravitelj poziva"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Dopusti usluzi upravljanje načinom uspostavljanja poziva."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Upravitelj poziva"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2451014351355183338">"Hitna emitiranja"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Mrežni operateri"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Pristupne točke"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Poboljšan 4G LTE način"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Upotreba LTE podataka radi poboljšanja glasovnih značajki i komunikacije (preporučeno)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Željena vrsta mreže"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (preporučeno)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Radni SIM"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Pristup aplikacijama i sadržaju"</string>
    <string name="user_rename" msgid="8523499513614655279">"PREIMENOVANJE"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Postavljanje ograničenja aplikacije"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Kontrolira aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_not_supported_in_limited" msgid="913035259626149121">"Ta aplikacija nije podržana u ograničenim profilima"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ta aplikacija može pristupiti vašim računima"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi‑Fi i mobilne mreže"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Dopusti izmjenu postavki Wi‑Fi i mobilne mreže"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Dopusti izmjene uparivanja i postavki Bluetootha"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Dopusti razmjenu podataka kada <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dodiruje drugi NFC uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Dopusti razmjenu podataka kada tablet dodiruje drugi uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Dopusti razmjenu podataka kada telefon dodiruje drugi uređaj"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Dopusti aplikacijama da upotrebljavaju podatke o lokaciji"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Natrag"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Dalje"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Završi"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Snimite fotografiju"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Odaberite fotografiju iz Galerije"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"SIM kartice"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"SIM kartice"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"SIM kartice su se promijenile"</string>
    <string name="sim_cards_changed_message_summary" msgid="5452545583546944683">"Dodirnite za postavljanje aktivnosti"</string>
    <string name="sim_cellular_data_unavailable" msgid="9018555543451203035">"Mobilni podaci nisu dostupni"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="3654805961942166428">"Dodirnite za odabir podatkovnog SIM-a"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Uvijek upotrebljavaj za pozive"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Odabir SIM kartice"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"SIM je prazan"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Naziv SIM-a"</string>
    <string name="sim_editor_title" msgid="6364331907415443358">"SIM kartica"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Mobilni operater"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Broj"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Boja SIM-a"</string>
    <string name="sim_editor_num_format" msgid="4681231191387098783">"Prikaži brojeve"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Odaberite SIM karticu"</string>
    <string name="color_orange" msgid="4417567658855022517">"Narančasta"</string>
    <string name="color_purple" msgid="3888532466427762504">"Ljubičasta"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"SIM kartica nije umetnuta"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Status SIM-a"</string>
    <string name="sim_status_summary" msgid="4934558018015161369">"Informacije povezane sa SIM-om"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Uzvratni poziv sa zadanog SIM-a"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"SIM za odlazne pozive"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Ostale postavke poziva"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Rastereti željenu mrežu"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Ne emitiraj naziv mreže"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Onemogućivanje emitiranja naziva mreže sprječava treće strane da pristupe podacima o vašoj mreži."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Onemogućivanje emitiranja naziva mreže spriječit će automatsko povezivanje sa skrivenim mrežama."</string>
    <string name="sim_pref_divider" msgid="4194064766764348209">"Aktivnosti"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="2897913529999035350">"Najprije pitaj"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Potreban je odabir"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Postavke"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Postavke"</string>
    <string name="search_menu" msgid="7053532283559077164">"Pretražite"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Postavke pretraživanja"</string>
    <string name="search_recents_queries_label" msgid="2128811638532309069">"Nedavna pretraživanja"</string>
    <string name="search_results_label" msgid="4163304782363526148">"Rezultati"</string>
    <string name="keywords_wifi" msgid="8947676711698613374">"wifi wi-fi mreža veza"</string>
    <string name="keywords_more_default_sms_app" msgid="2744404159003574745">"SMS poruka"</string>
    <string name="keywords_more_mobile_networks" msgid="7813380887358745769">"mobilni mobitel mobilni operater bežično"</string>
    <string name="keywords_home" msgid="3626170808219458848">"pokretač"</string>
    <string name="keywords_display" msgid="6709007669501628320">"zaslon dodirni zaslon"</string>
    <string name="keywords_display_brightness_level" msgid="8636451602230815191">"zatamnjenje zaslon dodirni zaslon"</string>
    <string name="keywords_display_auto_brightness" msgid="8070218600502753102">"zatamnjenje zaslon dodirni zaslon"</string>
    <string name="keywords_display_wallpaper" msgid="4315466287469834939">"u pozadini"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"veličina teksta"</string>
    <string name="keywords_display_cast_screen" msgid="8887412173792143329">"projekcija"</string>
    <string name="keywords_storage" msgid="7007275853993419928">"memorija disk tvrdi disk"</string>
    <string name="keywords_battery" msgid="3992479295298655138">"napajanje"</string>
    <string name="keywords_spell_checker" msgid="4509482591225399210">"pravopis"</string>
    <string name="keywords_voice_input" msgid="3519547605812413860">"prepoznavanje unos govor govoriti jezik bez ruku uvredljiva riječ audio povijest bluetooth slušalice"</string>
    <string name="keywords_text_to_speech_output" msgid="8207889472282225512">"brzina jezik zadano govoriti govor"</string>
    <string name="keywords_date_and_time" msgid="7666950126499155141">"sat"</string>
    <string name="keywords_factory_data_reset" msgid="3693730656843989732">"uklanjanje brisanje"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"pisač"</string>
    <string name="keywords_sounds_and_notifications" msgid="5965996187974887000">"zvučnik kratak zvučni signal"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="2912933812460077912">"ne ometaj prekinuti prekid zaustaviti"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="782326973714313480">"u blizini lokacija povijest izvješćivanje"</string>
    <string name="keywords_location_mode" msgid="8584992704568356084">"točnost"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"račun"</string>
    <string name="keywords_users" msgid="4673901601478559100">"ograničenje ograničiti ograničeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="1103378692379215672">"ispravljanje teksta ispraviti zvuk vibracija automatski jezik pokret predložiti prijedlog tema uvredljiva riječ pisati emoji"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Postavite oznaku NFC za Wi-Fi"</string>
    <string name="write_tag" msgid="8571858602896222537">"Piši"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Dodirnite oznaku da biste zapisali podatke..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Nevažeća zaporka, pokušajte ponovo."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Uspjeli ste!"</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Nije moguće zapisati podatke u oznaku NFC. Ako problem potraje, pokušajte upotrijebiti drugačiju oznaku."</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"U oznaku NFC ne mogu se zapisati podaci. Upotrijebite drugačiju oznaku."</string>
    <string name="default_sound" msgid="8821684447333687810">"Zadani zvuk"</string>
    <string name="notification_settings" msgid="8791730980212496561">"Zvuk i obavijest"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Glasnoća medija"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Glasnoća alarma"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Glasnoća zvona"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Glasnoća obavijesti"</string>
    <string name="zen_mode_settings_title" msgid="7014915558669122902">"Prekidi"</string>
    <string name="zen_mode_option_title" msgid="5061978632306007914">"Kada stignu pozivi i obavijesti"</string>
    <string name="zen_mode_option_title_novoice" msgid="6680706009915204785">"Kad stignu obavijesti"</string>
    <string name="zen_mode_option_off" msgid="3167702608910820883">"Uvijek prekidaj"</string>
    <string name="zen_mode_option_important_interruptions" msgid="2320263300561981257">"Dopusti samo prioritetne prekide"</string>
    <string name="zen_mode_option_no_interruptions" msgid="5664234817617301449">"Ne prekidaj"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Melodija zvona telefona"</string>
    <string name="notification_ringtone_title" msgid="3361201340352664272">"Zadana melodija zvona za obavijesti"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibracija i za pozive"</string>
    <string name="notification_section_header" msgid="95661783916799134">"Obavijest"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Pulsno svjetlo obavijesti"</string>
    <string name="lock_screen_notifications_title" msgid="9118805570775519455">"Kada je uređaj zaključan"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Prikaži sav sadržaj obavijesti"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Sakrij osjetljiv sadržaj obavijesti"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3001013816427963576">"Uopće ne prikazuj obavijesti"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Kada je uređaj zaključan, kako želite da se obavijesti prikazuju?"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Obavijesti aplikacije"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Ostali zvukovi"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonovi površine za biranje brojeva"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvukovi zaključavanja zaslona"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvukovi priključivanja"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvukovi dodirivanja"</string>
    <string name="vibrate_on_touch_title" msgid="674710566941697253">"Vibracija na dodir"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Priključna stanica reproducira"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Sve zvukove"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Samo medijske zvukove"</string>
    <string name="emergency_tone_silent" msgid="1067515631635824291">"Bešumno"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Upozorenje"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Vibriranje"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Pristup obavijestima"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikacije ne mogu čitati obavijesti"</string>
  <plurals name="manage_notification_access_summary_nonzero">
    <item quantity="one" msgid="8344183614159211585">"%d aplikacija može čitati obavijesti"</item>
    <item quantity="other" msgid="980049191810249052">"Ovoliko aplikacija može čitati obavijesti: %d"</item>
  </plurals>
    <string name="no_notification_listeners" msgid="2767405417723149879">"Nema instaliranih slušatelja obavijesti."</string>
    <string name="notification_listener_security_warning_title" msgid="6494221261778885893">"Omogućiti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="2780319203595885564">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> moći će čitati sve obavijesti koje objavi sustav ili bilo koja instalirana aplikacija, a obavijesti mogu uključivati osobne podatke, primjerice, imena kontakata i tekstove poruka koje su vam poslane. Također će moći odbaciti te obavijesti ili dodirnuti gumbe za radnju u njima."</string>
    <string name="manage_condition_providers" msgid="3039306415273606730">"Davatelji uvjeta"</string>
    <string name="manage_condition_providers_summary_zero" msgid="3760902189574984100">"Nijedna aplikacija ne pruža uvjete"</string>
  <plurals name="manage_condition_providers_summary_nonzero">
    <item quantity="one" msgid="7871716594997778198">"%d aplikacija pruža uvjete"</item>
    <item quantity="other" msgid="358057362115673258">"Broj aplikacija koje pružaju uvjete: %d"</item>
  </plurals>
    <string name="no_condition_providers" msgid="6183782892066424125">"Nije instaliran nijedan davatelj uvjeta."</string>
    <string name="condition_provider_security_warning_title" msgid="5834347345913614926">"Želite li omogućiti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="condition_provider_security_warning_summary" msgid="640037330610551763">"Davatelj uvjeta <xliff:g id="CONDITION_PROVIDER_NAME">%1$s</xliff:g> moći će dodati uvjete za izlaz načinu Ne ometaj."</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Učitavanje aplikacija..."</string>
    <string name="app_notification_block_title" msgid="172237877395761371">"Blokiraj"</string>
    <string name="app_notification_block_summary" msgid="9049487483231233726">"Nikad ne prikazuj obavijesti s te aplikacije"</string>
    <string name="app_notification_priority_title" msgid="1967189807102076587">"Prioritet"</string>
    <string name="app_notification_priority_summary" msgid="7513344552201639232">"Prikaži obavijesti pri vrhu popisa i nastavi ih prikazivati kada je uređaj postavljen samo na prioritetne prekide"</string>
    <string name="app_notification_sensitive_title" msgid="7707233094233553192">"Osjetljivo"</string>
    <string name="app_notification_sensitive_summary" msgid="8850104564623526005">"Kada je uređaj zaključan, sakrij osjetljivi sadržaj u obavijestima te aplikacije"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokirano"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prioritet"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Osjetljivo"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Gotovo"</string>
    <string name="zen_mode_default_option" msgid="6940069025071935243">"Dok to ne isključite"</string>
    <string name="zen_mode_important_category" msgid="8123274463331022993">"Prioritetni prekidi"</string>
    <string name="zen_mode_downtime_category" msgid="4730179065426038108">"Prekid rada (samo prioritetni prekidi)"</string>
    <string name="zen_mode_downtime_days" msgid="3361856902633311616">"Dani"</string>
    <string name="zen_mode_downtime_days_none" msgid="8454857121193391322">"Nijedan"</string>
    <string name="zen_mode_automation_category" msgid="4653551005950835761">"Automatizacija"</string>
    <string name="zen_mode_entry_conditions_title" msgid="8467976490601914289">"Automatski uključi"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="zen_mode_entry_conditions_summary_none" msgid="6589476427475076533">"Nikada"</string>
    <string name="zen_mode_phone_calls" msgid="2872774457193013585">"Telefonski pozivi"</string>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Poruke"</string>
    <string name="zen_mode_from" msgid="1777739391289980762">"Od"</string>
    <string name="zen_mode_from_anyone" msgid="1180865188673992959">"Svatko"</string>
    <string name="zen_mode_from_contacts" msgid="8751503728985572786">"Samo kontakti"</string>
    <string name="zen_mode_from_starred" msgid="2168651127340381533">"Samo kontakti sa zvjezdicom"</string>
    <string name="zen_mode_alarm_info" msgid="5061362593677527505">"Alarmi i ostali osobni podsjetnici uvijek su prioritet"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Automatski uključi"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikada"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Svake noći"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Noći radnih dana"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Vrijeme početka"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Vrijeme završetka"</string>
    <string name="zen_mode_end_time_summary_format" msgid="1941585278888784451">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> sutra"</string>
    <string name="notification_settings_apps_title" msgid="1125354590652967250">"Obavijest aplikacije"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Postavke obavijesti"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Pošalji povr. informacije o uređaju"</string>
    <string name="restr_pin_enter_admin_pin" msgid="2451187374960131018">"Unesite PIN administratora"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Uključeno"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Isključeno"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Prikvačivanje zaslona"</string>
    <string name="screen_pinning_description" msgid="3022868253807792488">"Kada je ta postavka uključena, možete postaviti uređaj tako da prikaz ostane na trenutačnom zaslonu.\n\nDa biste prikvačili zaslon:\n\n1. Uključite tu postavku.\n\n2. Otvorite aplikaciju.\n\n3. Dodirnite gumb Najnoviji.\n\n4. Dodirnite ikonu pribadače."</string>
    <string name="managed_user_title" msgid="8101244883654409696">"Radni profil"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Eksperimentalno)"</string>
</resources>
