<?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="phoneAppLabel" product="tablet" msgid="8576272342240415145">"Mobilni podaci"</string>
    <string name="phoneAppLabel" product="default" msgid="906161039445636857">"Telefon"</string>
    <string name="emergencyDialerIconLabel" msgid="7812140032168171053">"Birač hitnih poziva"</string>
    <string name="phoneIconLabel" msgid="2331230813161304895">"Telefon"</string>
    <string name="fdnListLabel" msgid="8630418672279521003">"Popis FDN-a"</string>
    <string name="unknown" msgid="6878797917991465859">"Nepoznato"</string>
    <string name="private_num" msgid="6713286113000232309">"Privatni broj"</string>
    <string name="payphone" msgid="1931775086311769314">"Telefonska govornica"</string>
    <string name="onHold" msgid="9035493194749959955">"Na čekanju"</string>
    <string name="mmiStarted" msgid="6347869857061147003">"Pokrenut je MMI kôd"</string>
    <string name="ussdRunning" msgid="485588686340541690">"Pokrenut je USSD kôd…"</string>
    <string name="mmiCancelled" msgid="2771923949751842276">"Otkazan je MMI kôd"</string>
    <string name="cancel" msgid="5044513931633602634">"Odustani"</string>
    <string name="enter_input" msgid="1810529547726803893">"USSD poruka mora imati ovoliko znakova: <xliff:g id="MIN_LEN">%d</xliff:g> – <xliff:g id="MAX_LEN">%d</xliff:g>. Pokušajte ponovo."</string>
    <string name="manageConferenceLabel" msgid="4691922394301969053">"Upravljanje konferencijskim pozivom"</string>
    <string name="ok" msgid="3811371167865772377">"U redu"</string>
    <string name="audio_mode_speaker" msgid="27649582100085266">"Zvučnik"</string>
    <string name="audio_mode_earpiece" msgid="4156527186373869107">"Slušalice"</string>
    <string name="audio_mode_wired_headset" msgid="1465350758489175975">"Žičane slušalice"</string>
    <string name="audio_mode_bluetooth" msgid="3047641300848211128">"Bluetooth"</string>
    <string name="wait_prompt_str" msgid="7601815427707856238">"Poslati sljedeće tonove?\n"</string>
    <string name="pause_prompt_str" msgid="1789964702154314806">"Slanje tonova\n"</string>
    <string name="send_button" msgid="4106860097497818751">"Pošalji"</string>
    <string name="pause_prompt_yes" msgid="3564467212025151797">"Da"</string>
    <string name="pause_prompt_no" msgid="6686238803236884877">"Ne"</string>
    <string name="wild_prompt_str" msgid="5543521676355533577">"Zamijeni zamjenski znak s"</string>
    <string name="no_vm_number" msgid="4164780423805688336">"Nedostaje broj govorne pošte"</string>
    <string name="no_vm_number_msg" msgid="1300729501030053828">"Na SIM kartici nije spremljen broj govorne pošte."</string>
    <string name="add_vm_number_str" msgid="4676479471644687453">"Dodaj broj"</string>
    <string name="puk_unlocked" msgid="2284912838477558454">"Vaša je SIM kartica odblokirana. Telefon se odblokira…"</string>
    <string name="label_ndp" msgid="780479633159517250">"Mrežni PIN za otključavanje SIM-a"</string>
    <string name="sim_ndp_unlock_text" msgid="683628237760543009">"Otključaj"</string>
    <string name="sim_ndp_dismiss_text" msgid="1604823375752456947">"Odbaci"</string>
    <string name="requesting_unlock" msgid="6412629401033249351">"Traženje mrežnog otključavanja..."</string>
    <string name="unlock_failed" msgid="6490531697031504225">"Neuspješan zahtjev za otključavanje mreže."</string>
    <string name="unlock_success" msgid="6770085622238180152">"Mrežno otključavanje bilo je uspješno."</string>
    <string name="mobile_network_settings_not_available" msgid="7355254462995117896">"Postavke mobilne mreže nisu dostupne za tog korisnika"</string>
    <string name="labelGSMMore" msgid="5930842194056092106">"Postavke GSM poziva"</string>
    <string name="labelCDMAMore" msgid="1630676740428229339">"Postavke CDMA poziva"</string>
    <string name="apn_settings" msgid="9043423184895642077">"Nazivi pristupnih točaka"</string>
    <string name="settings_label" msgid="3876743539816984008">"Postavke mreže"</string>
    <string name="connection_service" msgid="978745922583410219">"Usluga povezivanja koja će se upotrijebiti"</string>
    <string name="connection_service_default_label" msgid="1498481943805913754">"Ugrađena usluga povezivanja"</string>
    <string name="voicemail" msgid="8693759337917898954">"Govorna pošta"</string>
    <string name="voicemail_abbreviated" msgid="2215592488517217448">"VM:"</string>
    <string name="networks" msgid="8873030692174541976">"Mrežni operateri"</string>
    <string name="call_settings" msgid="1630474923393095156">"Postavke poziva"</string>
    <string name="additional_gsm_call_settings" msgid="1391795981938800617">"Dodatne postavke"</string>
    <string name="sum_gsm_call_settings" msgid="4076647190996778012">"Dodatne postavke samo za GSM poziv"</string>
    <string name="additional_cdma_call_settings" msgid="8628958775721886909">"Dodatne postavke za CDMA poziv"</string>
    <string name="sum_cdma_call_settings" msgid="284753265979035549">"Dodatne postavke samo za CDMA poziv"</string>
    <string name="labelNwService" msgid="4699970172021870983">"Postavke mrežne usluge"</string>
    <string name="labelCallerId" msgid="3888899447379069198">"ID pozivatelja"</string>
    <string name="sum_loading_settings" msgid="1826692909391168620">"Učitavanje postavki…"</string>
    <string name="sum_hide_caller_id" msgid="1071407020290873782">"Broj je skriven u izlaznim pozivima"</string>
    <string name="sum_show_caller_id" msgid="6768534125447290401">"Broj prikazan za izlazne pozive"</string>
    <string name="sum_default_caller_id" msgid="1954518825510901365">"Koristiti zadane postavke operatera za prikaz mog broja kod odlaznih poziva"</string>
    <string name="labelCW" msgid="6120513814915920200">"Poziv na čekanju"</string>
    <string name="sum_cw_enabled" msgid="8083061901633671397">"Obavijesti me tijekom poziva o dolaznim pozivima"</string>
    <string name="sum_cw_disabled" msgid="3648693907300104575">"Obavijesti me tijekom poziva o dolaznim pozivima"</string>
    <string name="call_forwarding_settings" msgid="3378927671091537173">"Postavke preusmjeravanja poziva"</string>
    <string name="labelCF" msgid="2574386948026924737">"Preusmjeravanje poziva"</string>
    <string name="labelCFU" msgid="8147177368148660600">"Uvijek preusmjeri"</string>
    <string name="messageCFU" msgid="3560082430662923687">"Uvijek koristi ovaj broj"</string>
    <string name="sum_cfu_enabled_indicator" msgid="4014187342724130197">"Preusmjeravanje svih poziva"</string>
    <string name="sum_cfu_enabled" msgid="2450052502198827927">"Preusmjeravanje poziva na <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfu_enabled_no_number" msgid="6591985777096823616">"Broj je nedostupan"</string>
    <string name="sum_cfu_disabled" msgid="3698472522160364904">"Onemogućeno"</string>
    <string name="labelCFB" msgid="218938523102207587">"Preusmjeri ako je zauzeto"</string>
    <string name="messageCFB" msgid="3711089705936187129">"Broj u slučaju zauzeća"</string>
    <string name="sum_cfb_enabled" msgid="5984198104833116690">"Preusmjeravanje na <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfb_disabled" msgid="227440009979537651">"Onemogućeno"</string>
    <string name="disable_cfb_forbidden" msgid="3506984333877998061">"Vaš mobilni operater ne podržava onemogućavanje preusmjeravanja poziva ako je vaš telefon zauzet."</string>
    <string name="labelCFNRy" msgid="3646316323834351390">"Preusmjeri u slučaju ako nema odgovora"</string>
    <string name="messageCFNRy" msgid="672317899884380374">"Broj ako nema odgovora"</string>
    <string name="sum_cfnry_enabled" msgid="6955775691317662910">"Preusmjeravanje na <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfnry_disabled" msgid="8422350929957344729">"Onemogućeno"</string>
    <string name="disable_cfnry_forbidden" msgid="4308233959150658058">"Vaš mobilni operater ne podržava onemogućavanje preusmjeravanja poziva ako se na vaš telefon nitko ne javi."</string>
    <string name="labelCFNRc" msgid="47183615370850000">"Preusmjeri ako nije dostupno"</string>
    <string name="messageCFNRc" msgid="6380695421020295119">"Broj u slučaju nedostupnosti"</string>
    <string name="sum_cfnrc_enabled" msgid="7010898346095497421">"Preusmjeravanje na <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfnrc_disabled" msgid="7222141261321276464">"Onemogućeno"</string>
    <string name="disable_cfnrc_forbidden" msgid="5646361343094064333">"Vaš mobilni operater ne podržava onemogućavanje preusmjeravanja poziva ako je vaš telefon nedostupan."</string>
    <string name="updating_title" msgid="6146755386174019046">"Postavke poziva"</string>
    <string name="error_updating_title" msgid="7970259216988931777">"Pogreška postavki poziva"</string>
    <string name="reading_settings" msgid="1920291699287055284">"Postavke čitanja..."</string>
    <string name="updating_settings" msgid="8171225533884883252">"Ažuriranje postavki..."</string>
    <string name="reverting_settings" msgid="4752151682666912828">"Povrat postavki…"</string>
    <string name="response_error" msgid="6674110501330139405">"Neočekivan mrežni odgovor."</string>
    <string name="exception_error" msgid="7027667130619518211">"Pogreška mreže ili SIM kartice."</string>
    <string name="fdn_check_failure" msgid="18200614306525434">"Uključena je postavka fiksnog biranja u aplikaciji telefona. Zbog toga ne rade neke značajke u vezi s pozivima."</string>
    <string name="radio_off_error" msgid="2304459933248513376">"Uključite radio prije pregleda ovih postavki."</string>
    <string name="close_dialog" msgid="2365884406356986917">"U redu"</string>
    <string name="enable" msgid="1059008390636773574">"Omogući"</string>
    <string name="disable" msgid="7274240979164762320">"Onemogući"</string>
    <string name="change_num" msgid="239476305819844391">"Ažuriraj"</string>
  <string-array name="clir_display_values">
    <item msgid="5560134294467334594">"Zdana postavka mreže"</item>
    <item msgid="7876195870037833661">"Sakrij broj"</item>
    <item msgid="1108394741608734023">"Prikaži broj"</item>
  </string-array>
    <string name="vm_changed" msgid="380744030726254139">"Broj govorne pošte je promijenjen."</string>
    <string name="vm_change_failed" msgid="3352934863246208918">"Nije bilo moguće promijeniti broj govorne pošte.\nObratite se mobilnom operateru ako problem potraje."</string>
    <string name="fw_change_failed" msgid="5298103228470214665">"Nije bilo moguće promijeniti broj za preusmjeravanje.\nObratite se mobilnom operateru ako problem potraje."</string>
    <string name="fw_get_in_vm_failed" msgid="8862896836093833973">"Dohvaćanje i spremanje trenutačnih postavki broja za prosljeđivanje nije uspjelo.\nŽelite li se ipak prebaciti na novog davatelja usluge?"</string>
    <string name="no_change" msgid="3186040086622435212">"Nisu izvršene nikakve promjene."</string>
    <string name="sum_voicemail_choose_provider" msgid="59911196126278922">"Odaberite uslugu govorne pošte"</string>
    <string name="voicemail_default" msgid="5902099213882352338">"Moj mobilni operater"</string>
    <string name="mobile_networks" msgid="5540397602919106177">"Postavke mobilne mreže"</string>
    <string name="label_available" msgid="1181658289009300430">"Dostupne mreže"</string>
    <string name="load_networks_progress" msgid="5230707536168902952">"Pretraživanje…"</string>
    <string name="empty_networks_list" msgid="4249426905018815316">"Nije pronađena mreža."</string>
    <string name="search_networks" msgid="1601136049300882441">"Pretraži mreže"</string>
    <string name="network_query_error" msgid="6828516148953325006">"Pogreška tijekom pretraživanja mreža."</string>
    <string name="register_on_network" msgid="9055203954040805084">"Prijava na <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="5613353860205691579">"Vaša SIM kartica ne dopušta povezivanje s ovom mrežom."</string>
    <string name="connect_later" msgid="2308119155752343975">"Povezivanje s tom mrežom trenutačno nije moguće. Pokušajte kasnije."</string>
    <string name="registration_done" msgid="495135664535876612">"Registrirano na mreži."</string>
    <string name="sum_carrier_select" msgid="3494252551249882718">"Odaberite mrežnog operatera"</string>
    <string name="sum_search_networks" msgid="2921092249873272715">"Pretraži sve dostupne mreže"</string>
    <string name="select_automatically" msgid="5628402124471810174">"Odaberi automatski"</string>
    <string name="sum_select_automatically" msgid="5614890115123292400">"Automatski odabir željene mreže"</string>
    <string name="register_automatically" msgid="6017849844573519637">"Automatska prijava…"</string>
    <string name="preferred_network_mode_title" msgid="2336624679902659306">"Željena vrsta mreže"</string>
    <string name="preferred_network_mode_summary" msgid="1434820673166126609">"Promijenite način rada mreže"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4048082093347807230">"Željena vrsta mreže"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="8521677230113533809">"Način željene mreže: Preferirano WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="3352445413437453511">"Način željene mreže: Samo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="2836897236221063413">"Način željene mreže: Samo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="3161255745326408587">"Način željene mreže: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="3175690187294334241">"Način željene mreže: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="8332063064712726618">"Način željene mreže: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="1309770926198634150">"Način željene mreže: Samo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="8472220691721269155">"Način željene mreže: Samo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="4726682079415227330">"Preferirani mrežni način: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="574752287596469136">"Preferirani mrežni način: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="8455358514068283935">"Preferirani mrežni način: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="228702246343742853">"Preferirani mrežni način: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_global_summary" msgid="1633134285545730364">"Preferirani mrežni način: globalni"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="9180775701594742750">"Preferirani mrežni način: LTE/WCDMA"</string>
  <string-array name="preferred_network_mode_choices">
    <item msgid="7886739962255042385">"LTE/WCDMA"</item>
    <item msgid="577652050447385699">"LTE"</item>
    <item msgid="6813597571293773656">"Globalno"</item>
    <item msgid="127064712132619032">"GSM/WCDMA/LTE"</item>
    <item msgid="1126767511633425977">"CDMA + LTE/EvDo"</item>
    <item msgid="6389676313771670660">"CDMA/EvDo/GSM/WCDMA"</item>
    <item msgid="545430093607698090">"Samo EvDo"</item>
    <item msgid="1508557726283094448">"CDMA bez EvDo-a"</item>
    <item msgid="4341433122263841224">"Automatski CDMA/EvDo"</item>
    <item msgid="5958053792390386668">"Automatski GSM/WCDMA"</item>
    <item msgid="7913148405605373434">"Samo WCDMA"</item>
    <item msgid="1524224863879435516">"Samo GSM"</item>
    <item msgid="3817924849415716259">"Preferirano GSM/WCDMA"</item>
  </string-array>
    <string name="data_enabled" msgid="5972538663568715366">"Podaci su omogućeni"</string>
    <string name="data_enable_summary" msgid="5022018967714633874">"Omogući podatkovni pristup preko mobilne mreže"</string>
    <string name="roaming" msgid="8871412572928323707">"Roaming podataka"</string>
    <string name="roaming_enable" msgid="7331106985174381987">"Poveži se s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_disable" msgid="1843417228755568110">"Poveži se s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_reenable_message" msgid="8913735676127858115">"Izgubili ste podatkovnu vezu jer ste izašli iz matične mreže s isključenim roamingom podataka."</string>
    <string name="roaming_warning" msgid="7820963598559553967">"Omogućiti roaming podataka? Može doći do znatno većih troškova za roaming!"</string>
    <string name="gsm_umts_options" msgid="6538311689850981686">"Opcije za GSM/UMTS"</string>
    <string name="cdma_options" msgid="4016822858172249884">"CDMA opcije"</string>
    <string name="throttle_data_usage" msgid="3715677828160555808">"Korištenje podataka"</string>
    <string name="throttle_current_usage" msgid="8762280193043815361">"Podaci korišteni za trenutačno razdoblje"</string>
    <string name="throttle_time_frame" msgid="1915198770363734685">"Razdoblje korištenja podataka"</string>
    <string name="throttle_rate" msgid="4710388992676803508">"Pravilo za brzinu prijenosa podataka"</string>
    <string name="throttle_help" msgid="243651091785169900">"Saznajte više"</string>
    <string name="throttle_status_subtext" msgid="1657318943142085170">"<xliff:g id="USED_0">%1$s</xliff:g> (<xliff:g id="USED_1">%2$d</xliff:g>٪) od <xliff:g id="USED_2">%3$s</xliff:g> maksimalnog razdoblja\nSljedeće razdoblje počinje za ovoliko dana: <xliff:g id="USED_3">%4$d</xliff:g> (<xliff:g id="USED_4">%5$s</xliff:g>)"</string>
    <string name="throttle_data_usage_subtext" msgid="6029276011123694701">"<xliff:g id="USED_0">%1$s</xliff:g> (<xliff:g id="USED_1">%2$d</xliff:g>٪) od <xliff:g id="USED_2">%3$s</xliff:g> maksimalnog razdoblja"</string>
    <string name="throttle_data_rate_reduced_subtext" msgid="7492763592720107737">"<xliff:g id="USED_0">%1$s</xliff:g> maksimum je prekoračen\nBrzina prijenosa podataka smanjena je na <xliff:g id="USED_1">%2$d</xliff:g> Kb/s"</string>
    <string name="throttle_time_frame_subtext" msgid="7732763021560399960">"Proteklo je <xliff:g id="USED_0">%1$d</xliff:g>٪ ciklusa\nSljedeće razdoblje počinje za ovoliko dana: <xliff:g id="USED_1">%2$d</xliff:g> (<xliff:g id="USED_2">%3$s</xliff:g>)"</string>
    <string name="throttle_rate_subtext" msgid="2149102656120726855">"Brzina prijenosa podatak smanjena je na <xliff:g id="USED">%1$d</xliff:g> Kb/s ako se prekorači ograničenje korištenja podataka"</string>
    <string name="throttle_help_subtext" msgid="5217706521499010816">"Više informacija o pravilima korištenja mobilne podatkovne mreže vašeg davatelja mobilne usluge"</string>
    <string name="cell_broadcast_sms" msgid="5584192824053625842">"SMS iz mobilne mreže"</string>
    <string name="enable_disable_cell_bc_sms" msgid="4851147873691392255">"SMS iz mobilne mreže"</string>
    <string name="cell_bc_sms_enable" msgid="6441688565738921084">"Omogućen je SMS iz mobilne mreže"</string>
    <string name="cell_bc_sms_disable" msgid="3398365088309408749">"Onemogućen je SMS iz mobilne mreže"</string>
    <string name="cb_sms_settings" msgid="651715019785107312">"Postavke SMS-a iz mobilne mreže"</string>
    <string name="enable_disable_emergency_broadcast" msgid="2157014609041245335">"Hitan prijenos"</string>
    <string name="emergency_broadcast_enable" msgid="2645980025414010211">"Omogućen je hitan prijenos"</string>
    <string name="emergency_broadcast_disable" msgid="3665199821267569426">"Onemogućen je Hitan prijenos"</string>
    <string name="enable_disable_administrative" msgid="6501582322182059412">"Administracija"</string>
    <string name="administrative_enable" msgid="1750086122962032235">"Administracija je omogućena"</string>
    <string name="administrative_disable" msgid="8433273857248698539">"Administracija je onemogućena"</string>
    <string name="enable_disable_maintenance" msgid="1819693083025106678">"Održavanje"</string>
    <string name="maintenance_enable" msgid="8566636458770971189">"Održavanje omogućeno"</string>
    <string name="maintenance_disable" msgid="7340189100885066077">"Održavanje je onemogućeno"</string>
    <string name="general_news_settings" msgid="4968779723948432978">"Opće vijesti"</string>
    <string name="bf_news_settings" msgid="3935593091894685267">"Poslovne i financijske vijesti"</string>
    <string name="sports_news_settings" msgid="7649399631270052835">"Vijesti iz sporta"</string>
    <string name="entertainment_news_settings" msgid="5051153952959405035">"Vijesti iz svijeta zabave"</string>
    <string name="enable_disable_local" msgid="7890281063123416120">"Lokalno"</string>
    <string name="local_enable" msgid="6370463247609136359">"Omogućene su lokalne vijesti"</string>
    <string name="local_disable" msgid="4405691986943795798">"Onemogućene su lokalne vijesti"</string>
    <string name="enable_disable_regional" msgid="4905652414535565872">"Regionalno"</string>
    <string name="regional_enable" msgid="4434680415437834759">"Omogućene su regionalne vijesti"</string>
    <string name="regional_disable" msgid="5359325527213850077">"Onemogućene su regionalne vijesti"</string>
    <string name="enable_disable_national" msgid="236278090206880734">"Nacionalno"</string>
    <string name="national_enable" msgid="1172443648912246952">"Omogućene su nacionalne vijesti"</string>
    <string name="national_disable" msgid="326018148178601166">"Nacionalne vijesti su onemogućene"</string>
    <string name="enable_disable_international" msgid="7535348799604565592">"Međunarodno"</string>
    <string name="international_enable" msgid="5855356769925044927">"Međunarodne su vijesti omogućene"</string>
    <string name="international_disable" msgid="2850648591041088931">"Onemogućeni su međunarodni pozivi"</string>
    <string name="list_language_title" msgid="2841683501919760043">"Jezik"</string>
    <string name="list_language_summary" msgid="8109546531071241601">"Odaberite jezik vijesti"</string>
  <string-array name="list_language_entries">
    <item msgid="6137851079727305485">"engleski"</item>
    <item msgid="1151988412809572526">"francuski"</item>
    <item msgid="577840534704312665">"španjolski"</item>
    <item msgid="8385712091143148180">"japanski"</item>
    <item msgid="1858401628368130638">"korejski"</item>
    <item msgid="1933212028684529632">"kineski"</item>
    <item msgid="1908428006803639064">"hebrejski"</item>
  </string-array>
  <string-array name="list_language_values">
    <item msgid="1804908636436467150">"1"</item>
    <item msgid="289708030346890334">"2"</item>
    <item msgid="1121469729692402684">"3"</item>
    <item msgid="2614093115912897722">"4"</item>
    <item msgid="2411164639857960614">"5"</item>
    <item msgid="5884448729274543324">"6"</item>
    <item msgid="5511864807618312598">"7"</item>
  </string-array>
    <string name="list_language_dtitle" msgid="5442908726538951934">"Jezici"</string>
    <string name="enable_disable_local_weather" msgid="986967454867219114">"Lokalna vremenska prognoza"</string>
    <string name="local_weather_enable" msgid="6199315114382448922">"Omogućena je lokalna vremenska prognoza"</string>
    <string name="local_weather_disable" msgid="2510158089142626480">"Onemogućeno je lokalno vrijeme"</string>
    <string name="enable_disable_atr" msgid="8339572391278872343">"Izvješća o području prometa"</string>
    <string name="atr_enable" msgid="5541757457789181799">"Omogućena su izvješća o području prometa"</string>
    <string name="atr_disable" msgid="7085558154727596455">"Onemogućena su izvješća o području prometa"</string>
    <string name="enable_disable_lafs" msgid="668189073721277199">"Raspored letova za lokalnu zrakoplovnu luku"</string>
    <string name="lafs_enable" msgid="2791978667205137052">"Omogućen je raspored letova za lokalnu zrakoplovnu luku"</string>
    <string name="lafs_disable" msgid="2391212397725495350">"Onemogućen je raspored letova za lokalnu zrakoplovnu luku"</string>
    <string name="enable_disable_restaurants" msgid="6240381945336814024">"Restorani"</string>
    <string name="restaurants_enable" msgid="5137657479469118847">"Restorani omogućeni"</string>
    <string name="restaurants_disable" msgid="3678480270938424092">"Restorani onemogućeni"</string>
    <string name="enable_disable_lodgings" msgid="1822029172658551202">"Boravište"</string>
    <string name="lodgings_enable" msgid="3230042508992850322">"Učitavanje omogućeno"</string>
    <string name="lodgings_disable" msgid="3387879742320682391">"Onemogućeno je boravište"</string>
    <string name="enable_disable_retail_directory" msgid="1357809784475660303">"Maloprodajni imenik"</string>
    <string name="retail_directory_enable" msgid="3280626290436111496">"Omogućen je maloprodajni imenik"</string>
    <string name="retail_directory_disable" msgid="6479739816662879027">"Onemogućen je maloprodajni imenik"</string>
    <string name="enable_disable_advertisements" msgid="5999495926176182128">"Oglašavanje"</string>
    <string name="advertisements_enable" msgid="2050305021264683786">"Oglašavanje je omogućeno"</string>
    <string name="advertisements_disable" msgid="8350985908788707935">"Onemogućeno je oglašavanje"</string>
    <string name="enable_disable_stock_quotes" msgid="6397810445293533603">"Burzovne kotacije"</string>
    <string name="stock_quotes_enable" msgid="4384802470887170543">"Omogućene su burzovne kotacije"</string>
    <string name="stock_quotes_disable" msgid="4781450084565594998">"Onemogućene su burzovne kotacije"</string>
    <string name="enable_disable_eo" msgid="4863043263443942494">"Prilike za zapošljavanje"</string>
    <string name="eo_enable" msgid="8623559062015685813">"Omogućene su Prilike za zapošljavanje"</string>
    <string name="eo_disable" msgid="3863812478090907609">"Onemogućene su Prilike za zapošljavanje"</string>
    <string name="enable_disable_mhh" msgid="908214593528968522">"Zdravstvo, zdravlje i bolnice"</string>
    <string name="mhh_enable" msgid="5544500632306446815">"Omogućeno je zdravstvo, zdravlje i bolnice"</string>
    <string name="mhh_disable" msgid="8998210550117117437">"Onemogućeno je zdravstvo, zdravlje i bolnice"</string>
    <string name="enable_disable_technology_news" msgid="3517184627114999149">"Vijesti iz tehnologije"</string>
    <string name="technology_news_enable" msgid="7995209394210455181">"Omogućene su vijesti iz tehnologije"</string>
    <string name="technology_news_disable" msgid="5483490380561851946">"Vijesti iz tehnologije su onemogućene"</string>
    <string name="enable_disable_multi_category" msgid="626771003122899280">"Višestruka kategorija"</string>
    <string name="multi_category_enable" msgid="1179299804641721768">"Omogućena je višestruka kategorija"</string>
    <string name="multi_category_disable" msgid="880104702904139505">"Onemogućena je višestruka kategorija"</string>
    <string name="network_lte" msgid="7702681952521375754">"LTE (preporučeno)"</string>
    <string name="network_4G" msgid="2723512640529983138">"4G (preporučeno)"</string>
    <string name="network_global" msgid="1323190488685355309">"Globalno"</string>
    <string name="cdma_system_select_title" msgid="5757657769327732833">"Odabir sustava"</string>
    <string name="cdma_system_select_summary" msgid="60460043745797517">"Promijeni način rada CDMA roaminga"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6083355415165359075">"Odabir sustava"</string>
  <string-array name="cdma_system_select_choices">
    <item msgid="176474317493999285">"Samo matično"</item>
    <item msgid="1205664026446156265">"Automatski"</item>
  </string-array>
    <string name="cdma_subscription_title" msgid="1162564010076763284">"CDMA pretplata"</string>
    <string name="cdma_subscription_summary" msgid="2530890766115781140">"Izmjenjivanje među RUIM/SIM i NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="2699527950523333110">"pretplata"</string>
  <string-array name="cdma_subscription_choices">
    <item msgid="2258014151300708431">"RUIM/SIM"</item>
    <item msgid="5127722015571873880">"NV"</item>
  </string-array>
  <string-array name="cdma_subscription_values">
    <item msgid="7494167883478914080">"0"</item>
    <item msgid="6043847456049107742">"1"</item>
  </string-array>
    <string name="cdma_activate_device" msgid="3793805892364814518">"Aktivacija uređaja"</string>
    <string name="cdma_lte_data_service" msgid="4255018217292548962">"Postavljanje podatkovne usluge"</string>
    <string name="carrier_settings_title" msgid="9028166176523012300">"Postavke mobil. operatera"</string>
    <string name="fdn" msgid="7878832555095183202">"Brojevi za fiksno biranje"</string>
    <string name="manage_fdn_list" msgid="8777755791892122369">"Popis FDN-a"</string>
    <string name="fdn_activation" msgid="2156479741307463576">"Aktivacija FDN-a"</string>
    <string name="fdn_enabled" msgid="5238109009915521240">"Brojevi za fiksno biranje su omogućeni"</string>
    <string name="fdn_disabled" msgid="4700049736675368279">"Brojevi za fiksno biranje su onemogućeni"</string>
    <string name="enable_fdn" msgid="3740191529180493851">"Omogući FDN"</string>
    <string name="disable_fdn" msgid="7944020890722540616">"Onemogući FDN"</string>
    <string name="change_pin2" msgid="2153563695382176676">"Promijeni PIN2"</string>
    <string name="enable_fdn_ok" msgid="7215588870329688132">"Onemogući FDN"</string>
    <string name="disable_fdn_ok" msgid="5727046928930740173">"Omogući FDN"</string>
    <string name="sum_fdn" msgid="1959399454900272878">"Upravljanje brojeva za fiksno biranje"</string>
    <string name="sum_fdn_change_pin" msgid="6666549734792827932">"Promijeni PIN za FDN pristup"</string>
    <string name="sum_fdn_manage_list" msgid="8431088265332628316">"Upravljaj popisom telefonskih brojeva"</string>
    <string name="voice_privacy" msgid="3776841382844614716">"Privatnost za glasovnu uslugu"</string>
    <string name="voice_privacy_summary" msgid="3159383389833516214">"Omogući poboljšani način privatnosti"</string>
    <string name="tty_mode_option_title" msgid="9033098925144434669">"Način TTY"</string>
    <string name="tty_mode_option_summary" msgid="1073835131534808732">"Postavi način TTY"</string>
    <string name="auto_retry_mode_title" msgid="4073265511427813322">"Automatski ponovni pokušaj"</string>
    <string name="auto_retry_mode_summary" msgid="4973886004067532288">"Omogući način automatskog ponovnog pokušaja"</string>
    <string name="menu_add" msgid="1882023737425114762">"Dodaj kontakt"</string>
    <string name="menu_edit" msgid="7143003705504672374">"Uredi kontakt"</string>
    <string name="menu_delete" msgid="3977150783449642851">"Izbriši kontakt"</string>
    <string name="get_pin2" msgid="8204677063922225311">"Upišite PIN2"</string>
    <string name="name" msgid="7329028332786872378">"Ime"</string>
    <string name="number" msgid="7905950798349903858">"Broj"</string>
    <string name="save" msgid="4094274636321939086">"Spremi"</string>
    <string name="add_fdn_contact" msgid="2481915899633353976">"Dodaj broj za fiksno biranje"</string>
    <string name="adding_fdn_contact" msgid="7627379633721940991">"Dodavanje broja za fiksno biranje…"</string>
    <string name="fdn_contact_added" msgid="7458335758501736665">"Dodan je broj za fiksno biranje."</string>
    <string name="edit_fdn_contact" msgid="7976936035587081480">"Uredi broj za fiksno biranje"</string>
    <string name="updating_fdn_contact" msgid="8370929876849803600">"Ažuriranje broja za fiksno biranje…"</string>
    <string name="fdn_contact_updated" msgid="5497828782609005017">"Ažuriran je broj za fiksno biranje."</string>
    <string name="delete_fdn_contact" msgid="6668958073074151717">"Izbriši broj za fiksno biranje"</string>
    <string name="deleting_fdn_contact" msgid="5669163206349319969">"Brisanje broja za fiksno biranje…"</string>
    <string name="fdn_contact_deleted" msgid="7154162327112259569">"Izbrisan je broj za fiksno biranje."</string>
    <string name="pin2_invalid" msgid="5470854099230755944">"FDN nije ažuriran jer ste upisali pogrešan PIN."</string>
    <string name="fdn_invalid_number" msgid="1494755047900009147">"FDN nije ažuriran jer broj ne može premašivati 20 znamenki."</string>
    <string name="pin2_or_fdn_invalid" msgid="6025144083384701197">"FDN nije ažuriran. PIN2 nije točan ili je telefonski broj odbijen."</string>
    <string name="fdn_failed" msgid="540018079008319747">"Operacija FDN nije uspjela."</string>
    <string name="simContacts_emptyLoading" msgid="2203331234764498011">"Čitanje sa SIM kartice…"</string>
    <string name="simContacts_empty" msgid="5270660846489561932">"Nema kontakata na vašoj SIM kartici."</string>
    <string name="simContacts_title" msgid="1861472842524839921">"Odaberite kontakte za uvoz"</string>
    <string name="simContacts_airplaneMode" msgid="1846161429087789936">"Za uvoz kontakata sa SIM kartice prvo isključite način rada u zrakoplovu."</string>
    <string name="enable_pin" msgid="5422767284133234860">"Omogući/onemogući PIN za SIM"</string>
    <string name="change_pin" msgid="9174186126330785343">"Promijeni PIN za SIM"</string>
    <string name="enter_pin_text" msgid="8532615714751931951">"PIN za SIM:"</string>
    <string name="oldPinLabel" msgid="5287773661246368314">"Stari PIN"</string>
    <string name="newPinLabel" msgid="207488227285336897">"Novi PIN"</string>
    <string name="confirmPinLabel" msgid="257597715098070206">"Potvrdi novi PIN"</string>
    <string name="badPin" msgid="8955102849303984935">"Stari PIN koji ste unijeli nije točan. Pokušajte ponovo."</string>
    <string name="mismatchPin" msgid="5923253370683071889">"PIN-ovi koje ste unijeli međusobno se ne podudaraju. Pokušajte ponovo."</string>
    <string name="invalidPin" msgid="5981171102258684792">"Unesite PIN koji ima od 4 do 8 brojeva."</string>
    <string name="disable_sim_pin" msgid="3992926931620188855">"Onemogući SIM PIN"</string>
    <string name="enable_sim_pin" msgid="5803702443844458831">"Omogući PIN za SIM"</string>
    <string name="enable_in_progress" msgid="3695303775100109650">"Pričekajte…"</string>
    <string name="enable_pin_ok" msgid="9166061915030865848">"Omogućen je PIN za SIM."</string>
    <string name="disable_pin_ok" msgid="5596999379593924850">"Onemogućen je PIN za SIM."</string>
    <string name="pin_failed" msgid="2298841192582192277">"PIN koji ste unijeli nije točan."</string>
    <string name="pin_changed" msgid="4365538014588501049">"Uspješno je promijenjen PIN SIM-a."</string>
    <string name="puk_requested" msgid="1796577128488773946">"Zaporka nije točna, PIN je blokiran! Potreban je PUK."</string>
    <string name="enter_pin2_text" msgid="8339444124477720345">"PIN2"</string>
    <string name="oldPin2Label" msgid="8559146795026261502">"Stari PIN2"</string>
    <string name="newPin2Label" msgid="4573956902204349054">"Novi PIN2"</string>
    <string name="confirmPin2Label" msgid="8100319484454787708">"Potvrdi novi PIN2"</string>
    <string name="badPuk2" msgid="4851734468010000418">"PUK2 koji ste unijeli nije točan. Pokušajte ponovo."</string>
    <string name="badPin2" msgid="1041576234483629991">"Stari PIN2 koji ste unijeli nije točan. Pokušajte ponovo."</string>
    <string name="mismatchPin2" msgid="523029155918113440">"Vaši unosi za PIN2 međusobno se ne podudaraju. Pokušajte ponovo."</string>
    <string name="invalidPin2" msgid="8237110107480395938">"Unesite PIN2 koji ima 4-8 brojeva."</string>
    <string name="invalidPuk2" msgid="1290977391033057871">"Unesite PUK2 koji ima 8 brojeva."</string>
    <string name="pin2_changed" msgid="1639666438836544393">"PIN2 uspješno je promijenjen."</string>
    <string name="label_puk2_code" msgid="302845876240219560">"Unesite PUK2 kôd"</string>
    <string name="fdn_enable_puk2_requested" msgid="3674058967950559397">"Zaporka nije točna, PIN2 je blokiran. Promijenite PIN2 i pokušajte ponovo!"</string>
    <string name="puk2_requested" msgid="8909278021238716877">"Zaporka nije točna, SIM je zaključan. Zatražen je PUK2."</string>
    <string name="puk2_blocked" msgid="3150263853077280049">"PUK2 je trajno blokiran."</string>
    <string name="pin2_attempts" msgid="7937503107162525324">\n"Imate još ovoliko preostalih pokušaja: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="pin2_unblocked" msgid="2903147240919055381">"PIN2 je deblokiran!"</string>
    <string name="doneButton" msgid="2859593360997984240">"Gotovo"</string>
    <string name="caller_manage_header" msgid="3231519674734638786">"Konferencijski poziv <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
    <string name="voicemail_settings_number_label" msgid="8524164258691887790">"Broj govorne pošte"</string>
    <string name="card_title_dialing" msgid="5769417478498348054">"Biranje broja"</string>
    <string name="card_title_redialing" msgid="4831412164303596395">"Ponovni pokušaj"</string>
    <string name="card_title_conf_call" msgid="1162980346189744501">"Konferencijski poziv"</string>
    <string name="card_title_incoming_call" msgid="7364539451234646909">"Dolazni poziv"</string>
    <string name="card_title_call_ended" msgid="5544730338889702298">"Poziv je završio"</string>
    <string name="card_title_on_hold" msgid="821463117892339942">"Na čekanju"</string>
    <string name="card_title_hanging_up" msgid="3999101620995182450">"Prekidanje veze"</string>
    <string name="card_title_in_call" msgid="6346543933068225205">"Poziv u tijeku"</string>
    <string name="card_title_my_phone_number" msgid="112428362494434191">"Moj broj je <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
    <string name="notification_dialing" msgid="2107666444937350731">"Biranje broja"</string>
    <string name="notification_missedCallTitle" msgid="7554385905572364535">"Propušteni poziv"</string>
    <string name="notification_missedCallsTitle" msgid="1361677948941502522">"Propušteni pozivi"</string>
    <string name="notification_missedCallsMsg" msgid="4575787816055205600">"Broj propuštenih poziva: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
    <string name="notification_missedCallTicker" msgid="504686252427747209">"Propušten poziv kontakta <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
    <string name="notification_ongoing_call" msgid="7068688957273482989">"Poziv u tijeku"</string>
    <string name="notification_on_hold" msgid="3480694969511790465">"Na čekanju"</string>
    <string name="notification_incoming_call" msgid="2820429205043529642">"Dolazni poziv"</string>
    <string name="notification_voicemail_title" msgid="8933468752045550523">"Nova govorna pošta"</string>
    <string name="notification_voicemail_title_count" msgid="4366360747660929916">"Nova govorna pošta (<xliff:g id="COUNT">%d</xliff:g>)"</string>
    <string name="notification_voicemail_text_format" msgid="4447323569453981685">"Biraj <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
    <string name="notification_voicemail_no_vm_number" msgid="760963466895609716">"Nepoznat je broj govorne pošte"</string>
    <string name="notification_network_selection_title" msgid="4224455487793492772">"Nema usluge"</string>
    <string name="notification_network_selection_text" msgid="2607085729661923269">"Odabrana mreža (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) je onemogućena"</string>
    <string name="notification_action_end_call" msgid="6069460915123531620">"Prekini vezu"</string>
    <string name="notification_missedCall_call_back" msgid="2684890353590890187">"Povratni poziv"</string>
    <string name="notification_missedCall_message" msgid="3049928912736917988">"Poruka"</string>
    <string name="incall_error_power_off" msgid="6550191216405193368">"Da biste uspostavili poziv, prvo isključite način rada u zrakoplovu."</string>
    <string name="incall_error_emergency_only" msgid="4678640422710818317">"Nije registrirano na mreži."</string>
    <string name="incall_error_out_of_service" msgid="8587993036435080418">"Mobilna mreža nije dostupna."</string>
    <string name="incall_error_no_phone_number_supplied" msgid="4197432103471807739">"Poziv nije uspostavljen, nije unijet valjani broj."</string>
    <string name="incall_error_call_failed" msgid="4313552620858880999">"Poziv nije poslan."</string>
    <string name="incall_status_dialed_mmi" msgid="3672498861336189563">"Pokretanje MMI sekvence…"</string>
    <string name="incall_error_supp_service_unknown" msgid="2991054870745666038">"Nepodržana usluga."</string>
    <string name="incall_error_supp_service_switch" msgid="3503552565745872241">"Nije moguće prebaciti pozive."</string>
    <string name="incall_error_supp_service_separate" msgid="914362338192301746">"Nije moguće odvojiti poziv."</string>
    <string name="incall_error_supp_service_transfer" msgid="2509871374644921632">"Nije moguće prenijeti poziv."</string>
    <string name="incall_error_supp_service_conference" msgid="2505727299596357312">"Nije moguće uspostaviti konferencijske pozive."</string>
    <string name="incall_error_supp_service_reject" msgid="7055164130563826216">"Nije moguće odbiti poziv."</string>
    <string name="incall_error_supp_service_hangup" msgid="7417583238334762737">"Nije moguće ostvariti pozi(e)."</string>
    <string name="incall_call_type_label_sip" msgid="2310958283037924371">"Internetski poziv"</string>
    <string name="emergency_enable_radio_dialog_title" msgid="4627849966634578257">"Hitan poziv"</string>
    <string name="emergency_enable_radio_dialog_message" msgid="207613549344420291">"Uključivanje radija…"</string>
    <string name="emergency_enable_radio_dialog_retry" msgid="3724423402363063736">"Izvan područja usluge, ponovni pokušaj..."</string>
    <string name="dial_emergency_error" msgid="7969515493359619960">"Poziv nije upućen. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nije broj za hitne pozive!"</string>
    <string name="dial_emergency_empty_error" msgid="5556166819619323893">"Poziv nije upućen. Birajte broj hitne službe!"</string>
    <string name="dialerKeyboardHintText" msgid="9192914825413747792">"Birajte pomoću tipkovnice"</string>
    <string name="onscreenHoldText" msgid="2285258239691145872">"Na čekanju"</string>
    <string name="onscreenEndCallText" msgid="4403855834875398585">"Kraj"</string>
    <string name="onscreenShowDialpadText" msgid="8561805492659639893">"Površina za biranje brojeva"</string>
    <string name="onscreenMuteText" msgid="5011369181754261374">"Isključi zvuk"</string>
    <string name="onscreenAddCallText" msgid="5140385634712287403">"Dodaj poziv"</string>
    <string name="onscreenMergeCallsText" msgid="6640195098064538950">"Spoji pozive"</string>
    <string name="onscreenSwapCallsText" msgid="1602990689244030047">"Zamijeni"</string>
    <string name="onscreenManageCallsText" msgid="5473231160123254154">"Upravljaj pozivima"</string>
    <string name="onscreenManageConferenceText" msgid="6485935856534311346">"Upravljanje konferencijom"</string>
    <string name="onscreenAudioText" msgid="1710087112800041743">"Zvuk"</string>
    <string name="onscreenVideoCallText" msgid="4800924186056115442">"Videopoziv"</string>
    <string name="importSimEntry" msgid="6614358325359736031">"Uvezi"</string>
    <string name="importAllSimEntries" msgid="1503181169636198673">"Uvezi sve"</string>
    <string name="importingSimContacts" msgid="7374056215462575769">"Uvoz SIM kontakata"</string>
    <string name="importToFDNfromContacts" msgid="2130620207013368580">"Uvezi iz kontakata"</string>
    <string name="hac_mode_title" msgid="8740268574688743289">"Pomoć za osobe oštećenog sluha"</string>
    <string name="hac_mode_summary" msgid="6833851160514929341">"Uključi kompatibilnost za pomoć osobama oštećenog sluha"</string>
  <string-array name="tty_mode_entries">
    <item msgid="512950011423868021">"Isključen je TTY"</item>
    <item msgid="3971695875449640648">"TTY je pun"</item>
    <item msgid="1937509904407445684">"TTY HCO"</item>
    <item msgid="5644925873488772224">"TTY VCO"</item>
  </string-array>
    <string name="dtmf_tones_title" msgid="5163153771291340803">"DTMF tonovi"</string>
    <string name="dtmf_tones_summary" msgid="3351820372864020331">"Postavite duljinu DTMF tonova"</string>
  <string-array name="dtmf_tone_entries">
    <item msgid="899650777817315681">"Normalni"</item>
    <item msgid="2883365539347850535">"Dugo"</item>
  </string-array>
    <string name="network_message" msgid="4483886461245213802">"Mrežna poruka"</string>
    <string name="ota_title_activate" msgid="8616918561356194398">"Aktivirajte svoj telefon"</string>
    <string name="ota_touch_activate" msgid="6553212803262586244">"Poseban poziv upućen je za aktiviranje telefonske usluge. \n\nNakon što pritisnete “Aktiviraj”, poslušajte upute za aktiviranje telefona."</string>
    <string name="ota_hfa_activation_title" msgid="2234246934160473981">"Aktivacija..."</string>
    <string name="ota_hfa_activation_dialog_message" msgid="8092479227918463415">"Telefon aktivira vašu podatkovnu mobilnu uslugu.\n\nTo može potrajati do 5 minuta."</string>
    <string name="ota_skip_activation_dialog_title" msgid="2943366608272261306">"Preskoči aktivaciju?"</string>
    <string name="ota_skip_activation_dialog_message" msgid="2440770373498870550">"Ako preskočite aktivaciju, ne možete pozivati niti se povezivati na mobilne podatkovne mreže (premda se možete prijaviti na Wi-Fi mreže).Sve dok ne aktivirate telefon prikazivat će se upit za aktiviranje kod svakog prijavljivanja."</string>
    <string name="ota_skip_activation_dialog_skip_label" msgid="3458532775091563208">"Preskoči"</string>
    <string name="ota_activate" msgid="1368528132525626264">"Aktiviraj"</string>
    <string name="ota_title_activate_success" msgid="6570240212263372046">"Telefon je aktiviran."</string>
    <string name="ota_title_problem_with_activation" msgid="7095824491970084367">"Problem s aktivacijom"</string>
    <string name="ota_listen" msgid="162923839877584937">"Slijedite govorne upute sve dok ne čujete da je aktivacija dovršena."</string>
    <string name="ota_speaker" msgid="6904589278542719647">"Zvučnik"</string>
    <string name="ota_progress" msgid="3420314892609254729">"Pričekajte dok ne završi programiranje vašeg telefona."</string>
    <string name="ota_failure" msgid="4311299546379674378">"Neuspješno programiranje"</string>
    <string name="ota_successful" msgid="1880780692887077407">"Vaš telefon nije aktiviran. Pokretanje usluge može potrajati i do 15 minuta."</string>
    <string name="ota_unsuccessful" msgid="8072141612635635357">"Vaš se telefon nije aktivirao. \nMožda biste trebali potražiti područje s boljom pokrivenošću (pored prozora ili vani). \n\nPokušajte ponovo ili nazovite korisničku službu za više opcija."</string>
    <string name="ota_spc_failure" msgid="3909983542575030796">"KVAR PRETJERANOG SPC-a"</string>
    <string name="ota_call_end" msgid="4537279738134612388">"Natrag"</string>
    <string name="ota_try_again" msgid="7685477206465902290">"Pokušajte ponovo"</string>
    <string name="ota_next" msgid="3904945374358235910">"Dalje"</string>
    <string name="ecm_exit_dialog" msgid="4448531867763097533">"EcmExitDialog"</string>
    <string name="phone_entered_ecm_text" msgid="6266424252578731203">"Unijet je način hitnog povratnog poziva"</string>
    <string name="phone_in_ecm_notification_title" msgid="3226896828951687085">"Način hitnog povratnog poziva"</string>
    <string name="phone_in_ecm_call_notification_text" msgid="4611608947314729773">"Onemogućena je podatkovna mreža"</string>
  <plurals name="phone_in_ecm_notification_time">
    <item quantity="one" msgid="4866221796252472622">"Nema podatkovne veze <xliff:g id="COUNT">%s</xliff:g> min"</item>
    <item quantity="other" msgid="3122217344579273583">"Nema podatkovne veze <xliff:g id="COUNT">%s</xliff:g> min"</item>
  </plurals>
  <plurals name="alert_dialog_exit_ecm">
    <item quantity="one" msgid="8060210887681426682">"Telefon će biti u načinu rada hitnog povratnog poziva <xliff:g id="COUNT">%s</xliff:g> min. Za to se vrijeme ne može upotrebljavati nijedna aplikacija kojoj je potrebna podatkovna veza. Želite li izaći sada?"</item>
    <item quantity="other" msgid="8617116564023933114">"Telefon će biti u načinu rada hitnog povratnog poziva <xliff:g id="COUNT">%s</xliff:g> min. Za to se vrijeme ne može upotrebljavati nijedna aplikacija kojoj je potrebna podatkovna veza. Želite li izaći sada?"</item>
  </plurals>
  <plurals name="alert_dialog_not_avaialble_in_ecm">
    <item quantity="one" msgid="2585506997024726599">"Odabrana radnja nije dostupna u načinu rada hitnog povratnog poziva. Telefon će biti u tom načinu rada <xliff:g id="COUNT">%s</xliff:g> min. Želite li izaći sada?"</item>
    <item quantity="other" msgid="6115622137771382224">"Odabrana radnja nije dostupna u načinu rada hitnog povratnog poziva. Telefon će biti u tom načinu rada <xliff:g id="COUNT">%s</xliff:g> min. Želite li izaći sada?"</item>
  </plurals>
    <string name="alert_dialog_in_ecm_call" msgid="1886723687211887104">"Odabrana radnja nije dostupna tijekom hitnog poziva."</string>
    <string name="progress_dialog_exiting_ecm" msgid="4835734101617817074">"Izlaz iz načina hitnog povratnog poziva"</string>
    <string name="alert_dialog_yes" msgid="6674268047820703974">"Da"</string>
    <string name="alert_dialog_no" msgid="1476091437797628703">"Ne"</string>
    <string name="alert_dialog_dismiss" msgid="2491494287075907171">"Odbaci"</string>
    <string name="voicemail_provider" msgid="5135942703327136909">"Usluga"</string>
    <string name="voicemail_settings" msgid="72448049107749316">"Postavljanje"</string>
    <string name="voicemail_number_not_set" msgid="6724904736891087856">"&lt;Nije postavljeno&gt;"</string>
    <string name="other_settings" msgid="3672912580359716394">"Ostale postavke poziva"</string>
    <string name="calling_via_template" msgid="4839419581866928142">"Pozivanje putem operatera <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="contactPhoto" msgid="4713193418046639466">"kontakt fotografija"</string>
    <string name="goPrivate" msgid="865837794424530980">"na privatno"</string>
    <string name="selectContact" msgid="781975788478987237">"odabir kontakta"</string>
    <string name="sip_settings" msgid="6699045718560859691">"Postavke internetskih poziva"</string>
    <string name="sip_accounts" msgid="2097054001288457163">"Računi za internetske pozive (SIP)"</string>
    <string name="sip_accounts_title" msgid="1212889069281054570">"Računi"</string>
    <string name="sip_receive_calls" msgid="5635685570889971559">"Primi dolazni poziv"</string>
    <string name="sip_receive_calls_summary" msgid="8403613238633679184">"Skraćuje trajanje baterije"</string>
    <string name="sip_call_options_title" msgid="27433718808839672">"Upotrijebi internetski poziv"</string>
    <string name="sip_call_options_wifi_only_title" msgid="145572394529090811">"Upotrijebi internetski poziv (samo Wi-Fi)"</string>
    <string name="sip_call_options_entry_1" msgid="6556668894178520760">"Za sve pozive kada je podatkovna mreža dostupna"</string>
    <string name="sip_call_options_entry_2" msgid="6789764029719494361">"Samo za internetske pozive"</string>
    <string name="sip_call_options_entry_3" msgid="7474809001402649185">"Upit za svaki poziv"</string>
    <string name="sip_call_options_wifi_only_entry_1" msgid="7423523864471650069">"Za sve pozive"</string>
    <string name="pick_outgoing_call_phone_type" msgid="5622916534828338675">"Nazovi"</string>
    <string name="pick_outgoing_sip_phone" msgid="7012322118236208875">"Upotrijebi račun za internetske pozive:"</string>
    <string name="remember_my_choice" msgid="7058059586169290705">"Uvijek upotrijebi za internetske pozive"</string>
    <string name="reset_my_choice_hint" msgid="5523030209803567922">"Možete promijeniti koji ćete internetski račun za pozivanje upotrebljavati prema zadanim postavkama iz opcije Telefon &gt; Postavke &gt; Postavke internetskih poziva &gt; Zaslon računa."</string>
    <string name="pstn_phone" msgid="8782554491484326429">"Poziv mobitelom"</string>
    <string name="internet_phone" msgid="1147922660195095810">"Internetski poziv"</string>
    <string name="no_sip_account_found_title" msgid="6266249392379373628">"Nema računa za internetske pozive"</string>
    <string name="no_sip_account_found" msgid="724325811961769997">"Na ovom telefonu nema računa za internetske pozive. Želite li sada dodati jedan?"</string>
    <string name="sip_menu_add" msgid="8757508498518881500">"Dodaj"</string>
    <string name="add_sip_account" msgid="5904858426290097611">"Dodavanje računa"</string>
    <string name="remove_sip_account" msgid="7645900420385682570">"Brisanje računa"</string>
    <string name="sip_account_list" msgid="5480058210652194306">"SIP računi"</string>
    <string name="saving_account" msgid="52903398217017954">"Spremanje računa…"</string>
    <string name="removing_account" msgid="7183999896088628100">"Uklanjanje računa…"</string>
    <string name="sip_menu_save" msgid="5842531129356014943">"Spremi"</string>
    <string name="sip_menu_discard" msgid="524075892158789701">"Odbaci"</string>
    <string name="alert_dialog_close" msgid="7759635137627626235">"Zatvori profil"</string>
    <string name="alert_dialog_ok" msgid="3580379406983564080">"U redu"</string>
    <string name="close_profile" msgid="6886968271423155284">"Zatvori"</string>
    <string name="primary_account_summary_with" msgid="1633960536212343187">"Primarni račun. <xliff:g id="REGISTRATION_STATUS">%s</xliff:g>"</string>
    <string name="registration_status_checking_status" msgid="3381868307694056727">"Provjeravanje statusa..."</string>
    <string name="registration_status_registering" msgid="4288401139400232968">"Prijava…"</string>
    <string name="registration_status_still_trying" msgid="3185581992666091911">"Još pokušavam…"</string>
    <string name="registration_status_not_receiving" msgid="4185572774980557758">"Ne prima pozive."</string>
    <string name="registration_status_no_data" msgid="4901476962360656611">"Prijava računa zaustavljena je jer nema internetske veze."</string>
    <string name="registration_status_no_wifi_data" msgid="4038976374713018067">"Prijava računa zaustavljena je jer nema Wi-Fi veze."</string>
    <string name="registration_status_not_running" msgid="4824867184446232131">"Prijava računa nije uspjela."</string>
    <string name="registration_status_done" msgid="884630717456439280">"Prima pozive."</string>
    <string name="registration_status_failed_try_later" msgid="5214474354451220581">"Registracija računa nije uspjela: (<xliff:g id="REGISTRATION_ERROR_MESSAGE">%s</xliff:g>); pokušat ćemo kasnije"</string>
    <string name="registration_status_invalid_credentials" msgid="4908446367559341757">"Prijava računa nije uspjela: netočno korisničko ime ili zaporka."</string>
    <string name="registration_status_server_unreachable" msgid="5733421582468991276">"Prijava računa nije uspjela: provjerite naziv poslužitelja."</string>
    <string name="third_party_account_summary" msgid="2532526738862533028">"Ovaj račun trenutačno upotrebljava aplikacija <xliff:g id="ACCOUNT_OWNER">%s</xliff:g>."</string>
    <string name="sip_edit_title" msgid="489288416435014385">"Detalji SIP računa"</string>
    <string name="sip_edit_new_title" msgid="3659149255856520385">"Detalji SIP računa"</string>
    <string name="domain_address_title" msgid="9071787581316160480">"Poslužitelj"</string>
    <string name="username_title" msgid="2479375923477682328">"Korisničko ime"</string>
    <string name="password_title" msgid="3323555249068171531">"Zaporka"</string>
    <string name="display_name_title" msgid="2459768196312249937">"Ime za prikaz"</string>
    <string name="proxy_address_title" msgid="4828301345351614273">"Odlazna proxy adresa"</string>
    <string name="port_title" msgid="5952939408078626657">"Broj porta"</string>
    <string name="transport_title" msgid="8253139511847746640">"Vrsta transporta"</string>
    <string name="send_keepalive_title" msgid="7533342573918645113">"Pošalji postavke keep-alive"</string>
    <string name="set_primary_title" msgid="5351892327447571451">"Postavi kao primarni račun"</string>
    <string name="set_primary_summary" msgid="2219064654523258577">"Upotrebljava se za odlazne pozive"</string>
    <string name="advanced_settings" msgid="8350631795335495338">"Izborne postavke"</string>
    <string name="auth_username_title" msgid="851473016307947120">"Korisničko ime za provjeru autentičnosti"</string>
    <string name="auth_username_summary" msgid="6782012405225938629">"Korisničko ime za provjeru autentičnosti"</string>
    <string name="default_preference_summary" msgid="868766740121667450">"&lt;Nije postavljeno&gt;"</string>
    <string name="display_name_summary" msgid="8636377460518225523">"&lt;Isto kao korisničko ime&gt;"</string>
    <string name="optional_summary" msgid="1464058793789832411">"&lt;Izborno&gt;"</string>
    <string name="advanced_settings_show" msgid="4668880308290857597">"▷ Dodirnite da biste prikazali sve"</string>
    <string name="advanced_settings_hide" msgid="217398292824758079">"▽ Dodirnite kako bi sakrili sve"</string>
    <string name="empty_alert" msgid="6839103946505432390">"Polje <xliff:g id="INPUT_FIELD_NAME">%s</xliff:g> obavezno je i ne može ostati prazno."</string>
    <string name="not_a_valid_port" msgid="4796149266434630292">"Broj priključka trebao bi biti između 1000 i 65534."</string>
    <string name="no_internet_available_title" msgid="3327109242858406165">"Nema internetske veze"</string>
    <string name="no_wifi_available_title" msgid="747881033089378758">"Nema Wi-Fi veze"</string>
    <string name="no_internet_available" msgid="7877142631803238549">"Za uspostavu internetskog poziva prvo provjerite internetsku vezu."</string>
    <string name="no_wifi_available" msgid="1225073547318465713">"Morate se povezati s Wi-Fi mrežom za internetske pozive (upotrijebite postavke Bežičnog povezivanja i mreža)."</string>
    <string name="no_voip" msgid="8901474054537199865">"Internetski pozivi nisu podržani"</string>
    <string name="sip_system_decide" msgid="368030746310423471">"Automatski"</string>
    <string name="sip_always_send_keepalive" msgid="8192080724632877132">"Uvijek šalji"</string>
    <string name="not_voice_capable" msgid="2739898841461577811">"Glasovni pozivi nisu podržani"</string>
    <string name="respond_via_sms_setting_title" msgid="3754000371039709383">"Brzi odgovori"</string>
    <string name="respond_via_sms_setting_summary" msgid="9150281183930613065"></string>
    <string name="description_image_button_one" msgid="5502718871331943463">"jedan"</string>
    <string name="description_image_button_two" msgid="4903738528222924522">"dva"</string>
    <string name="description_image_button_three" msgid="5570985408463782329">"tri"</string>
    <string name="description_image_button_four" msgid="1697520001239289074">"četiri"</string>
    <string name="description_image_button_five" msgid="3450276493026943454">"pet"</string>
    <string name="description_image_button_six" msgid="2070376172268675300">"šest"</string>
    <string name="description_image_button_seven" msgid="1757351311199993371">"sedam"</string>
    <string name="description_image_button_eight" msgid="4734693919020613227">"osam"</string>
    <string name="description_image_button_nine" msgid="5568534122590597040">"devet"</string>
    <string name="description_image_button_star" msgid="1976280813017254462">"zvjezdica"</string>
    <string name="description_image_button_zero" msgid="4211255756866893605">"nula"</string>
    <string name="description_image_button_pound" msgid="1716041284529917866">"funta"</string>
    <string name="description_dial_button" msgid="7459705245418435351">"biraj"</string>
    <string name="description_delete_button" msgid="4015842181592283903">"backspace"</string>
    <string name="description_target_answer" msgid="7205604197797472471">"Odgovori"</string>
    <string name="description_target_send_sms" msgid="2098326025587950144">"Pošalji SMS"</string>
    <string name="description_target_decline" msgid="4789834364389731957">"Odbij"</string>
    <string name="voicemail_notification_vibrate_when_title" msgid="8361970092063604886">"Vibracija"</string>
    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="5739583146522136440">"Vibracija"</string>
    <string name="voicemail_notification_ringtone_title" msgid="2609519527849101590">"Zvuk"</string>
    <string name="default_notification_description" msgid="78174796906240970">"Zadani zvuk (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
    <string name="ringtone_title" msgid="6374978286202084684">"Melodija zvona telefona"</string>
    <string name="vibrate_on_ring_title" msgid="9197564612065258960">"Vibrira dok zvoni"</string>
    <string name="dtmf_tone_enable_title" msgid="827601042915852989">"Tonovi biranja"</string>
    <string name="dial_pad_autocomplete" msgid="494525952035761075">"Samodovršavanje biranja brojeva"</string>
    <string name="preference_category_ringtone" msgid="5197960752529332721">"Melodija zvona i vibracija"</string>
    <string name="choose_wifi_for_call_msg" msgid="193549297122949976">"Želite li uputiti poziv putem Wi-Fi-ja?"</string>
    <string name="choose_wifi_for_call_yes" msgid="5312994368472630983">"Da"</string>
    <string name="choose_wifi_for_call_no" msgid="7132239734287157307">"Ne"</string>
    <string name="pstn_connection_service_label" msgid="1743245930577325900">"Ugrađene SIM kartice"</string>
    <string name="sip_connection_service_label" msgid="3547998349299125294">"Ugrađeni internetski pozivi"</string>
</resources>
