<?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="4944823405420438623">"BEŽIČNO POVEZIVANJE i MREŽE"</string>
    <string name="header_category_device" msgid="5781174212691167553">"UREĐAJ"</string>
    <string name="header_category_personal" msgid="6225932173498802187">"OSOBNO"</string>
    <string name="header_category_system" msgid="2073558547468647128">"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="5874340256342956252">"(AC)"</string>
    <string name="battery_info_status_charging_usb" msgid="4059070156126770959">"(USB)"</string>
    <string name="battery_info_status_charging_wireless" msgid="1822125795446772771">"(bežično povezivanje)"</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" product="tablet" msgid="787970073150631155">"Preimenuj tabletno računalo"</string>
    <string name="bluetooth_rename_device" product="default" msgid="6267987985556136749">"Preimenuj telefon"</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_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_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_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="457033227379858269">"Zahtjev telefonskog imenika"</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_pb_remember_choice" msgid="2901499974259177202">"Više me ne pitaj"</string>
    <string name="date_and_time" msgid="4114084177056654663">"Postavke datuma i vremena"</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="5912878565897294401">"Proxy postavke"</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="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_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="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="6889937359495515769">"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="2998818677094465517">"Upravljanje značajkama Wi-Fi, Bluetooth, način rada u zrakoplovu, mobilne mreže i VPN-ovi"</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\n"Ova 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\n"Ova 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" msgid="1193032284921000063">"Koristi 24-satni format"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Postavi vrijeme"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Odaberi vremensku zonu"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Postavi datum"</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="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="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="location_settings_title" msgid="4483843407328665068">"Pristup lokaciji"</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_encrypt_summary" product="tablet" msgid="6291564408810586">"Traži brojčani PIN ili zaporku za dekripciju tablet računala svaki put kada se uključi"</string>
    <string name="crypt_keeper_encrypt_summary" product="default" msgid="514138079795442371">"Traži brojčani PIN ili zaporku za dekripciju telefona svaki put kada se uključi"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Kriptirano"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="3839235202103924154">"Možete kriptirati svoje račune, postavke, preuzete aplikacije i njihove podatkovne, multimedijske i ostale datoteke. Nakon kriptiranja tabletnog računala morate upisati numerički PIN ili zaporku kako biste ga dešifrirali svaki put kada ga uključite: svoje tabletno računalo možete dešifrirati samo vraćanjem u tvorničko stanje čime se brišu svi vaši podaci."\n\n"Enkripcija traje jedan sat ili dulje. Morate započeti s napunjenom baterijom i tabletno računalo držati priključeno dok se enkripcija ne završi. Ako prekinete postupak enkripcije, izgubit ćete neke ili sve svoje podatke."</string>
    <string name="crypt_keeper_desc" product="default" msgid="7663118199519229502">"Možete kriptirati svoje račune, postavke, preuzete aplikacije i njihove podatkovne, multimedijske i ostale datoteke. Nakon kriptiranja telefona morate upisati numerički PIN ili zaporku kako biste ga dešifrirali svaki put kada ga uključite. Svoj telefon možete dešifrirati samo vraćanjem na tvorničke postavke čime se brišu svi vaši podaci."\n\n"Enkripcija traje jedan sat ili dulje. Morate započeti s napunjenom baterijom i telefon držati priključen dok se enkripcija ne završi. Ako prekinete postupak enkripcije, izgubit ćete neke ili sve svoje podatke."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Kriptiraj tablet uređaj"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"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_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_cooldown" msgid="685210918307862395">"Pokušajte ponovo za <xliff:g id="DELAY">^1</xliff:g> s."</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\n"Da 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\n"Da 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_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="2871898266296656162">"Klizanje"</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="5660014471997663139">"Klizanje"</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_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="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_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="5957007154213560390">"Traži uređaje"</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_devices" msgid="1970524193086791964">"Spareni uređaji"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Dostupni uređaji"</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="4793562956642282639">"Da biste vidjeli uređaje, uključite Bluetooth."</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_pan_nap" msgid="8429049285027482959">"Dijeljenje internetske veze"</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="3764437426089639639">"Profili"</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_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_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_display_settings_title" msgid="564299108014609382">"Bežični prikaz"</string>
    <string name="wifi_display_settings_empty_list_wifi_display_off" msgid="1225626898926363100">"Da biste vidjeli uređaje, uključite bežični prikaz."</string>
    <string name="wifi_display_settings_empty_list_wifi_display_disabled" msgid="7363832031876872257">"Bežični prikaz onemogućen je jer je Wi-Fi isključen."</string>
    <string name="wifi_display_search_for_devices" msgid="5065526281193354502">"Traži zaslone"</string>
    <string name="wifi_display_searching_for_devices" msgid="5172373825348672137">"Pretraživanje..."</string>
    <string name="wifi_display_no_devices_found" msgid="8180582698282377626">"Nije pronađen nijedan bežični zaslon u blizini."</string>
    <string name="wifi_display_paired_devices" msgid="7395326840730024303">"Upareni zasloni"</string>
    <string name="wifi_display_available_devices" msgid="4558314642853513487">"Dostupni uređaji"</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_available" msgid="1924167525172207067">"Dostupan"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Postavke zaslona"</string>
    <string name="wifi_display_disconnect_title" msgid="1543715924639003599">"Isključiti?"</string>
    <string name="wifi_display_disconnect_text" msgid="4824860802264489088">"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="wifi_display_options_title" msgid="5740656401635054838">"Opcije bežičnog prikaza"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Zaboravi"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Naziv"</string>
    <string name="wifi_display_summary_on" msgid="3695429596604962531">"Uključeno"</string>
    <string name="wifi_display_summary_off" msgid="2445210133184740611">"Isključeno"</string>
    <string name="wifi_display_summary_disabled" msgid="5318394806146587849">"Onemogućeno"</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\n"Jednostavno 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="874495178395350104">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="1047950931623694366">"Uključi Wi-Fi"</string>
    <string name="wifi_settings" msgid="1277428034634973011">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="2810363951104753710">"Wi-Fi postavke"</string>
    <string name="wifi_settings_title" msgid="4351120897298124250">"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="70277346338812325">"Odaberite Wi-Fi mrežu"</string>
    <string name="wifi_starting" msgid="6716593470710880000">"Uključivanje značajke Wi-Fi…"</string>
    <string name="wifi_stopping" msgid="244864762599017659">"Isključivanje Wi-Fi mreže..."</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="3038290727701553612">"Obavijesti me ako postoji otvorena mreža"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Izbjegavati slabe veze"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2466956369738047669">"Ne upotrebljavati Wi-Fi mrežu ako internetska veza nije zadovoljavajuća"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="9107237003911220057">"Zadrži Wi-Fi tijekom mirovanja"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Pojavio se problem s promjenom postavke"</string>
    <string name="wifi_suspend_optimizations" msgid="387215679583759376">"Optimizacija Wi-Fija"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="7774946457510541054">"Minimiziraj potrošnju baterije kad je Wi-Fi uključen"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Dodaj mrežu"</string>
    <string name="wifi_access_points" msgid="2664629396767022441">"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="2575893749303670353">"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_empty_list_wifi_off" msgid="4722299515264875943">"Da biste vidjeli dostupne mreže, uključite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="3354911729026237372">"Traženje Wi-Fi mreža…"</string>
    <string name="wifi_other_network" msgid="1048006316504242214">"Ostale mreže…"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Više"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Autom. postavljanje (WPS)"</string>
    <string name="wifi_required_info_text" msgid="9014073093293520112">"Da bi se postavljanje dovršilo, vaše tabletno računalo treba pristupiti Wi-Fi mreži. Nakon postavljanja možete izmjenjivati mobilnu podatkovnu vezu i Wi-Fi."</string>
    <string name="wifi_show_advanced" msgid="1793703023711426246">"Prikaži napredne opcije"</string>
    <string name="wifi_wps_setup_title" msgid="6034518116333042484">"Postavljanje zaštićene mreže Wi-Fi"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Pokretanje WPS-a..."</string>
    <string name="wifi_wps_onstart_pbc" msgid="7204827509934892103">"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="8067502591043979939">"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="5754399645462924103">"Povezano s mrežom Wi-Fi <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_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_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_secured_first_item" msgid="4072076186051083451">"Osigurano značajkom <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_secured_second_item" msgid="1326000076939056265">", osigurano značajkom <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Nema"</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="3335132188969450252">"UPOZORENJE: mogući su dodatni troškovi za promet podataka."\n\n"Za postavljanje tabletnog računala može biti potrebna značajna mrežna aktivnost."</string>
    <string name="wifi_skipped_message" product="default" msgid="1192848364146401759">"UPOZORENJE: mogući su dodatni troškovi za promet podataka."\n\n"Za postavljanje telefona može biti potrebna značajna mrežna aktivnost."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="7682836089429990118">"UPOZORENJE: tabletno računalo neće moći potvrditi da je vaš softver ažuriran."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="3324261421359832263">"UPOZORENJE: telefon neće moći potvrditi da je vaš softver ažuriran."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="6904081070290941807">"Tabletno računalo nije se moglo povezati s ovom Wi-Fi mrežom."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="3894921379368046855">"Telefon se nije mogao povezati s ovom Wi-Fi mrežom."</string>
    <string name="wifi_advanced_titlebar" msgid="1627063574532930090">"Napredni Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi pojas frekvencije"</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_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="400503541488064638">"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="6961605862058056788">"Prijenosna pristupna WiFi točka"</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 WiFi pristupna točka <xliff:g id="NETWORK_SSID">%1$s</xliff:g>"</string>
    <string name="wifi_tether_failed_subtext" msgid="2654888578056042315">"Pogreška prijenosne WiFi pristupne točke"</string>
    <string name="wifi_tether_configure_ap_text" msgid="61237027772641155">"Postavljanje WiFi pristupne točke"</string>
    <string name="wifi_tether_configure_subtext" msgid="1927454307836232128">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g> prijenosna WiFi pristupna točka"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Prikaz"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvuk"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Melodija zvona telefona"</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="notification_pulse_title" msgid="1247988024534030629">"Pulsno svjetlo obavijesti"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Zvuk zvona"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Obavijest"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Koristi glasnoću dolaznog poziva za obavijesti"</string>
    <string name="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="vibrate_when_ringing_title" msgid="3885857358303178029">"Vibrira dok zvoni"</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="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="2354961343555249270">"Svjetlina"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Podesite svjetlinu zaslona"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Mirovanje"</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="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="3178510434642201544">"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."\n"PIN 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."\n"Mož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="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="3279383550222116235">"Vrsta mobilne mreže"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informacije o operateru"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Stanje mobilne mreže"</string>
    <string name="status_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="33109409206264790">"Wi-Fi MAC adresa"</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="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="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="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_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" 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="7967552516440151852">"Mobilne mreže"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja lokacija"</string>
    <string name="location_network_based" msgid="7472814266821714527">"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="7457348712272184793">"Lokacija utvrđena pomoću Wi-Fi točke"</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="2063630508212535241">"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="4622772178078818425">"Maknite prst ako ste gotovi."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3103250430366718996">"Povežite barem ovoliko točaka: <xliff:g id="NUMBER">%d</xliff:g>. Pokušajte ponovo:"</string>
    <string name="lockpattern_pattern_entered_header" msgid="8378617839439987962">"Uzorak je snimljen."</string>
    <string name="lockpattern_need_to_confirm" msgid="5144676887162575050">"Ponovno iscrtajte uzorak za potvrdu:"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2223856038485537716">"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_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_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="verify_applications" msgid="2959359554974828518">"Potvrdi aplikacije"</string>
    <string name="verify_applications_summary" msgid="6737505521913263792">"Onemogući ili upozori prije instalacije aplikacija koje mogu uzrokovati štetu"</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="1118129530999596317">"To će poništiti sve postavke za:"\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\n" Nećete izgubiti podatke iz aplikacija."</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_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="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="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_titlebar" msgid="765659257455000490">"Korisnički rječnik"</string>
    <string name="user_dict_single_settings_title" msgid="524997218433540614">"Osobni rječnik"</string>
    <string name="user_dict_multiple_settings_title" msgid="3735224433307996276">"Osobni rječnici"</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_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="current_input_method" msgid="234072873286056438">"Zadano"</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="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="bugreport_in_power" msgid="4548816486587403971">"Izvješća o bugovima u izborniku napajanja"</string>
    <string name="bugreport_in_power_summary" msgid="5764234382355067053">"U izbornik napajanja uključi opciju za izradu izvješća o bugovima"</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="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="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\n"Neke 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\n"Neke aplikacije možda neće raditi dok ih razvojni programeri ne ažuriraju."</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="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="launch_count_label" msgid="4019444833263957024">"Broj"</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_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\n"Nakon 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\n"Napomena: 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\n"1. korak: pritisnite i držite gumb za uključivanje/isključivanje dok ne začujete zvuk ili osjetite vibraciju."\n\n"2. korak: dodirnite i držite s dva prsta dok ne začujete zvučnu potvrdu."\n\n"Ako 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_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 uklj./isk. završava 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_toggle_script_injection_preference_title" msgid="7950932054266694403">"Poboljšavanje web-pristupačnosti"</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="accessibility_script_injection_allowed" msgid="7624804397748427621">"Dopušteno"</string>
    <string name="accessibility_script_injection_disallowed" msgid="8639525487720429182">"Nije dopušteno"</string>
    <string name="accessibility_script_injection_button_allow" msgid="2201503285877102870">"Omogući"</string>
    <string name="accessibility_script_injection_button_disallow" msgid="5697152768523270885">"Ne dopusti"</string>
    <string name="accessibility_service_security_warning_title" msgid="5421628151509995404">"Upotrijebiti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_service_security_warning_summary" product="tablet" msgid="8558441850832543571">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> može prikupiti sav tekst koji upisujete, izuzev zaporki. To uključuje osobne podatke kao što su brojevi kreditnih kartica. Također može prikupljati podatke o vašim interakcijama s tabletnim računalom."</string>
    <string name="accessibility_service_security_warning_summary" product="default" msgid="2869015914319424723">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> može prikupiti sav tekst koji upisujete, izuzev zaporki. To uključuje osobne podatke kao što su brojevi kreditnih kartica. Također može prikupljati podatke o vašim interakcijama s telefonom."</string>
    <string name="accessibility_service_disable_warning_title" msgid="3393956845814484859">"Zaustaviti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_service_disable_warning_summary" msgid="625013894287895398">"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_no_apps_title" msgid="5124097563864109821">"Trebate čitač zaslona?"</string>
    <string name="accessibility_service_no_apps_message" msgid="7751662416377046539">"TalkBack daje govorne povratne informacije kao pomoć slijepim i slabovidnim korisnicima. Želite li ga besplatno instalirati s usluge Android Market?"</string>
    <string name="accessibility_script_injection_security_warning_summary" msgid="7706858873495386310">"Želite li da aplikacije instaliraju skripte s Googlea koje će njihov sadržaj učiniti pristupačnijim?"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nije dan opis."</string>
    <string name="settings_button" msgid="3006713718908152930">"Postavke"</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="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="3093545080361658269">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Budan"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Signal mobilne mreže"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Vrijeme budnosti uređaja"</string>
    <string name="wifi_on_time" msgid="6310209835617490616">"Wi-Fi na vrijeme"</string>
    <string name="bluetooth_on_time" msgid="6157799524996162271">"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_wifi" msgid="2382791137776486974">"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="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="8234997940652067049">"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="2857401966985425427">"Podaci poslani"</string>
    <string name="usage_type_data_recv" msgid="7251090882025234185">"Primljeni podaci"</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="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="2272741639606146903">"Wi-Fi postavke"</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_display" msgid="5432795282958076557">"Baterija se koristi za prikaz i pozadinsko svjetlo"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Smanjite svjetlinu i/ili privremeni prekid zaslona"</string>
    <string name="battery_desc_wifi" msgid="1702486494565080431">"Baterija iskorištena upotrebom značajke Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="2085605314976704287">"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="7287643439298561315">"Ručno upravljajte GPS-om kako biste spriječili da ga aplikacija upotrebljava"</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="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="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="recognizer_title" msgid="3231385184559054457">"Alat za prepoznavanje glasa"</string>
    <string name="recognizer_settings_title" msgid="432493301215113154">"Glasovno pretraživanje"</string>
    <string name="recognizer_settings_summary" msgid="4472287934134546902">"Postavke za \"<xliff:g id="RECOGNIZER_NAME">%s</xliff:g>\""</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_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_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="2382963973155082629">"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="5960290421313061434">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_gps" msgid="1558173602059236567">"GPS"</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="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="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="9157861529438245957">"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="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="7218566008912418809">"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="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="untitled_apn" msgid="1230060359198685513">"Bez naslova"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Općenito"</string>
    <string name="sound_category_notification_title" msgid="3502115998790286943">"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="661074868726906436">"Postavljanje Wi-Fi mreže"</string>
    <string name="wifi_setup_title_editing_network" msgid="7304321031985059969">"Povezivanje s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="3747859666621319757">"Povezivanje s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>..."</string>
    <string name="wifi_setup_title_connected_network" msgid="209755856836003839">"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="595556546597351489">"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="5235991893829582459">"Dodirnite "<b>"Dalje"</b>" za nastavak postavljanja."\n\n"Dodirnite "<b>"Natrag"</b>" za povezivanje s 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_error" msgid="8703299118794272041">"Pogreška sinkronizacije"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinkronizacija nije uspjela"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinkronizacija aktivna"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinkronizacija"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sinkronizacija trenutačno ima problema. Uskoro će nastaviti s radom."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Dodavanje računa"</string>
    <string name="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" product="tablet" msgid="3086620478225952725">"Ovaj je račun potreban za neke aplikacije. Možete ga ukloniti samo vraćanjem tabletnog računala na tvorničke postavke (čime ćete izbrisati sve osobne podatke) na zaslonu Postavke &gt; Sigurnosna kopija i poništavanje."</string>
    <string name="remove_account_failed" product="default" msgid="6217238709175617517">"Ovaj je račun potreban za neke aplikacije. Možete ga ukloniti samo vraćanjem telefona na tvorničke postavke (čime ćete izbrisati sve osobne podatke) na zaslonu Postavke &gt; Sigurnosna kopija i poništavanje."</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="1574837328738396794">"Postavke za 4G"</string>
    <string name="wimax_settings_summary" msgid="3207355006084135453">"Postavljanje i upravljanje 4G mrežom i modemom"</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="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_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="show_hw_overdraw" msgid="1136884304711318251">"Prikaz preoptereć. GPU-a"</string>
    <string name="show_hw_overdraw_summary" msgid="4295714000923082647">"Najbolje do najgoreg: plavo, zeleno, svjetlocrveno, crveno"</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="enable_traces_title" msgid="7448835465859512430">"Omogući tragove"</string>
    <string name="enable_traces_dialog_title" msgid="5026490474669452929">"Odaberi omogućene tragove"</string>
    <string name="enable_traces_summary_none" msgid="1867562808503494163">"Trenutačno nema omogućenih tragova"</string>
    <string name="enable_traces_summary_num" msgid="8978230237777454269">"Broj trenutačno omogućenih tragova: <xliff:g id="NUM">%1$d</xliff:g>"</string>
    <string name="enable_traces_summary_all" msgid="3950139649125158247">"Svi su tragovi trenutačno omogućeni"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Omogući OpenGL praćenja"</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="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="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="data_usage_summary_title" msgid="3804110657238092929">"Potrošnja podataka"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Ciklus upotrebe podataka"</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_split_4g" msgid="5322857680792601899">"Zasebna upotreba mreže 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="8266875319417201085">"Prikaz upotrebe Wi-Fi mreže"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Prikaži Ethernet upotrebu"</string>
    <string name="data_usage_menu_metered" msgid="5056695223222541863">"Mobilne žarišne točke"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatska sinkronizacija podataka"</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="5211007048880167438">"Onemogućiti mobilne podatke?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Ograničenje za mobilne podatke"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Postavi ograničenje za 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Postavi ograničenje za 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="8575537650560665657">"Postavi ograničenje za Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="1728851922959017766">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobilno"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobilni uređaj"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Ništa"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Mobilni podaci"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"2G-3G podaci"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"4G podaci"</string>
    <string name="data_usage_app_settings" msgid="8430240158135453271">"Prikaz postavki aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="9149728936265100841">"Ograniči pozadinske podatke"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="518658001418490405">"Onemogući pozadinske podatke na mobilnim mrežama. Upotrijebit će se fiksne mreže ako su dostupne."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Za ograničenje poz. podat. za ovu apl. ograničite mob. podatke."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Ograničenje pozadinskih podataka?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Zbog te značajke aplikacija koja ovisi o pozadinskim podacima može prestati raditi kada su dostupne samo mobilne mreže."\n\n"U postavkama možete pronaći prikladnije kontrole prijenosa podataka."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="7086969103661420799">"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="7312283529426636845">"Sve promjene koje napravite na svojim računima na webu automatski će se kopirati na vaš tablet."\n\n"Neki računi također mogu automatski kopirati na web sve promjene koje napravite na tabletu. Tako funkcionira Google račun."\n\n"Da biste odabrali vrstu podataka koji će se za pojedini račun sinkronizirati, idite na Postavke &gt; Računi."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="2374996799819303283">"Sve promjene koje napravite na svojim računima na webu automatski će se kopirati na vaš telefon."\n\n"Neki računi također mogu automatski kopirati na web sve promjene koje napravite na telefonu. Tako funkcionira Google račun."\n\n"Da biste odabrali vrstu podataka koji će se za pojedini račun sinkronizirati, idite na Postavke &gt; Računi."</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="3893348029612821262">"Vaša podatkovna veza mobilnog uređaja bit će onemogućena kada dosegnete navedeno ograničenje."\n\n"Budući da potrošnju podataka mjeri vaše tabletno računalo, a vaš mobilni operater možda obračunava na neki drugi način, razmislite o postavljanju opreznijeg ograničenja."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="7962145861903746827">"Vaša podatkovna veza mobilnog uređaja bit će onemogućena kada dosegnete navedeno ograničenje."\n\n"Budući da potrošnju podataka mjeri vaš telefon, a vaš mobilni operater možda obračunava na neki drugi način, razmislite o postavljanju opreznijeg ograničenja."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Ograničenje pozadinskih podataka?"</string>
    <string name="data_usage_restrict_background" msgid="6387252645350792955">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge neće raditi ako niste povezani s Wi-Fi mrežom."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="2609163428726042269">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge neće raditi ako niste spojeni na Wi-Fi mrežu."\n\n"Ova postavka utječe na sve korisnike na ovom tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="8025473178302056174">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge neće raditi ako niste spojeni na Wi-Fi mrežu."\n\n"Ova postavka utječe na sve korisnike na ovom telefonu."</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="6204750602856383278">"Mobilne žarišne točke"</string>
    <string name="data_usage_metered_body" msgid="2446827764036316131">"Odaberite Wi-Fi mreže koje su mobilne žarišne točke. Aplikacijama se može ograničiti upotreba tih mreža dok su u pozadini. Aplikacije također mogu upozoriti prije upotrebe tih mreža za velika preuzimanja."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Mobilne mreže"</string>
    <string name="data_usage_metered_wifi" msgid="4151511616349458705">"Wi-Fi mreže"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="7566012564261138417">"Za odabir mobilnih žarišnih točaka uključite Wi-Fi."</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="user_settings_title" msgid="6151874007858148344">"Korisnici"</string>
    <string name="user_you_section" msgid="6247838798859425408">"Vi"</string>
    <string name="user_list_title" msgid="8866161687358773982">"Drugi korisnici"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Dodaj korisnika"</string>
    <string name="user_summary_active" msgid="4740649452346004418">"Aktivan"</string>
    <string name="user_summary_inactive" msgid="3758296246095054572">"Nije aktivan"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nije postavljen"</string>
    <string name="user_owner" msgid="3879126011135546571">"Vlasnik"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Nadimak"</string>
    <string name="user_add_user_title" msgid="3961861593718285403">"Dodaj novog korisnika"</string>
    <string name="user_add_user_message_long" msgid="2278524063301283723">"Ovaj uređaj možete dijeliti s drugima tako da stvorite nove korisnike. Svaki korisnik ima vlastiti prostor koji može prilagoditi sa svojim aplikacijama, pozadinom i sličnim stvarima. Korisnici također mogu podesiti postavke tabletnog računala, primjerice Wi-Fi, koje utječu na sve."\n\n"Nakon što stvorite novog korisnika, ta osoba mora proći postupak postavljanja."\n\n"Bilo koji korisnik može prihvatiti ažurirane dozvole aplikacija u ime svih drugih korisnika."</string>
    <string name="user_add_user_message_short" msgid="3310933423737035428">"Nakon što stvorite novog korisnika, ta osoba mora proći postupak postavljanja."\n\n"Bilo koji korisnik može prihvatiti ažurirane dozvole aplikacija u ime svih drugih korisnika."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Postaviti korisnika sada?"</string>
    <string name="user_setup_dialog_message" msgid="614037943337008555">"Provjerite može li osoba uzeti tabletno računalo i postaviti svoj prostor"</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_remove_user_menu" msgid="6897150520686691355">"<xliff:g id="USER_NAME">%1$s</xliff:g>: brisanje s uređaja"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Novi korisnik"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="3856148232937245711">"Ukloniti korisnika?"</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" product="tablet" msgid="4610106937214870034">"Prostor i podaci tog korisnika nestat će s ovog tabletnog računala. Ta se radnja ne može poništiti."</string>
    <string name="user_confirm_remove_message" product="default" msgid="8130264611683731142">"Prostor i podaci tog korisnika nestat će s ovog telefona. Ta se radnja ne može poništiti."</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="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="app_notifications_switch_label" msgid="9124072219553687583">"Prikaži obavijesti"</string>
    <string name="help_label" msgid="1107174367904110532">"Pomoć"</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="cell_broadcast_settings" msgid="8415582011920085222">"Poruke mobilne mreže"</string>
    <string name="cell_broadcast_settings_summary" msgid="3301339398950905913">"Odaberite vrste hitnih obavijesti za prikaz."</string>
</resources>
