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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Da"</string>
    <string name="no" msgid="5541738710521607130">"Ne"</string>
    <string name="create" msgid="986997212165228751">"Napravi"</string>
    <string name="allow" msgid="3763244945363657722">"Dozvoli"</string>
    <string name="deny" msgid="7326117222944479942">"Odbij"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Uključi"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Nepoznato"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="1646187747875476269">
      <item quantity="one">Treba da obavite još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> korak da biste postali programer.</item>
      <item quantity="few">Treba da obavite još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka da biste postali programer.</item>
      <item quantity="other">Treba da obavite još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka da biste postali programer.</item>
    </plurals>
    <string name="show_dev_on" msgid="2840850085134853754">"Postali ste programer!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nema potrebe, već ste programer."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Prvo omogućite opcije za programere."</string>
    <string name="header_category_wireless_networks" msgid="303445626075235229">"Bežična veza i mreže"</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Radi"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ne radi"</string>
    <string name="radioInfo_service_emergency" msgid="6838935881091760942">"Samo hitni pozivi"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio je isključen"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Nije u romingu"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Veza je prekinuta"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Povezivanje"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Povezano"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Obustavljeno"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Nepoznato"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="1816306320988638382">"Isključi USB memoriju"</string>
    <string name="sdcard_unmount" product="default" msgid="8078570285871053815">"Oslobađanje SD kartice"</string>
    <string name="sdcard_format" product="nosdcard" msgid="3248760426252305366">"Brisanje USB memorije"</string>
    <string name="sdcard_format" product="default" msgid="3676635435136326182">"Izbriši SD karticu"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Pregled"</string>
    <string name="preview_page_indicator_content_description" msgid="2790254666634885865">"Pregled, <xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. stranica od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1296835853522566260">"Omogućava da tekst na ekranu bude manji ili veći."</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Umanji"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Uvećaj"</string>
    <string name="font_size_preview_text_headline" msgid="1173103737980511652">"Primer teksta"</string>
    <string name="font_size_preview_text_title" msgid="6363561029914452382">"Čarobnjak iz Oza"</string>
    <string name="font_size_preview_text_subtitle" msgid="5806349524325544614">"Poglavlje 11: Čudesni Smaragdni grad Oza"</string>
    <string name="font_size_preview_text_body" msgid="3323732544011097199">"I pored toga što su im oči bile zaštićene zelenim naočarima, Doroti i njeni prijatelji su u prvom trenutku bili zaslepljeni sjajem čudesnog grada. Ulice su bile pune prelepih kuća sagrađenih od zelenog mermera i ukrašenih svetlucavim smaragdima. Hodali su pločnikom od istog zelenog mermera, a na mestima na kojima su se ploče spajale nalazili su se gusto poređani smaragdi koji su se presijavali na suncu. Čak je i nebo iznad grada bilo zelene boje, kao i sunčevi zraci. \n\nNa ulicama je bilo mnogo ljudi. Muškarci, žene i deca su šetali, pri čemu su svi nosili zelena odela i imali zelenkastu kožu. Posmatrali su Doroti i njeno neobično društvo sa čuđenjem, a deca su bežala i krila se iza svojih majki kad bi videla Lava. Međutim, niko im se nije obraćao. U ulici je bilo mnogo radnji, a Doroti je primetila da je u njima sve bilo zeleno. Prodavale su se zelene bombone i kokice, zelene cipele, zeleni šeširi i zelena odeća svih vrsta. Na jednom mestu je neki čovek prodavao zelenu limunadu, a Doroti je primetila da su je deca plaćala zelenim novčićima. \n\nČinilo se da nema konja niti bilo kakvih drugih životinja. Ljudi su stvari nosili u malim zelenim kolicima koja su gurali ispred sebe. Svi su izgledali srećno, zadovoljno i uspešno."</string>
    <string name="font_size_save" msgid="206892409190870726">"Potvrdi"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="6071836464978826249">"USB memorija"</string>
    <string name="sdcard_setting" product="default" msgid="3713462184783824923">"SD kartica"</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Vidljivo za sve obližnje Bluetooth uređaje (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Vidljivo za sve obližnje Bluetooth uređaje"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nije vidljivo za druge Bluetooth uređaje"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Vidljivo samo za uparene uređaje"</string>
    <string name="bluetooth_visibility_timeout" msgid="7611781967900196353">"Vreme čekanja za vidljivost"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="7405038248936935186">"Zaključaj govorno biranje"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4959591522483403402">"Spreči korišćenje bluetooth programa za biranje brojeva kada je ekran zaključan"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth uređaji"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Naziv uređaja"</string>
    <string name="bluetooth_device_details" msgid="630702184344217832">"Podešavanja uređaja"</string>
    <string name="bluetooth_profile_details" msgid="1269419918127093325">"Podešavanja profila"</string>
    <string name="bluetooth_name_not_set" msgid="4654357917928126208">"Nije podešen naziv, koristi se naziv naloga"</string>
    <string name="bluetooth_scan_for_devices" msgid="8143654526358934069">"Skeniraj za uređaje"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Preimenuj ovaj uređaj"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Preimenuj"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Prekidate vezu sa uređajem?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="1934297101665686854">"Telefon će prekinuti vezu sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="336622948210457991">"Tablet će prekinuti vezu sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="6944790936166852428">"Uređaj će prekinuti vezu sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="4173740094381092185">"Prekini vezu"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="909734990821975673">"Nemate dozvolu za promenu podešavanja Bluetooth-a."</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Upari novi uređaj"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_is_visible_message" msgid="3811631869768157387">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> je vidljiv uređajima u blizini dok su Bluetooth podešavanja otvorena."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="4782330594323261630">"Bluetooth adresa telefona: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="1257226691967432025">"Bluetooth adresa tableta: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="2863536947810007600">"Bluetooth adresa uređaja: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="777406775955421784">"Želite li da prekinete vezu sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="6379176741690311973">"Emitovanje"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Neimenovani Bluetooth uređaj"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Pretražuje se"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Nema Bluetooth uređaja u blizini."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Zahtev za Bluetooth uparivanje"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Zahtev za uparivanje"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Dodirnite da biste uparili sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="685424727760622632">"Primljene datoteke"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="7097860463458492953">"Datoteke prim. preko Bluetooth-a"</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth je isključen"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Dodirnite da biste ga uključili"</string>
    <string name="device_picker" msgid="2427027896389445414">"Izaberite Bluetooth uređaj"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da uključi Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da isključi Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Aplikacija želi da uključi Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Aplikacija želi da isključi Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="1273405567801929487">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da učini tablet vidljivim za druge Bluetooth uređaje na <xliff:g id="TIMEOUT">%2$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="7013223328571883275">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da učini telefon vidljivim za druge Bluetooth uređaje na <xliff:g id="TIMEOUT">%2$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="3266007454914144057">"Aplikacija želi da učini tablet vidljivim za druge Bluetooth uređaje na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="7989444746980501116">"Aplikacija želi da učini telefon vidljivim za druge Bluetooth uređaje na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="6482084870735107773">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da učini tablet vidljivim za druge Bluetooth uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="2352494279465502950">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da učini telefon vidljivim za druge Bluetooth uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="2732992604509910896">"Aplikacija želi da učini tablet vidljivim za druge Bluetooth uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="356982103612920264">"Aplikacija želi da učini telefon vidljivim za druge Bluetooth uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="6103655179509599427">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da uključi Bluetooth i učini tablet vidljivim za druge uređaje na <xliff:g id="TIMEOUT">%2$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="934276632311449337">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da uključi Bluetooth i učini telefon vidljivim za druge uređaje na <xliff:g id="TIMEOUT">%2$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="1284048348024444485">"Aplikacija želi da uključi Bluetooth i učini tablet vidljivim za druge uređaje na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="2661614145022629454">"Aplikacija želi da uključi Bluetooth i učini telefon vidljivim za druge uređaje na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="8588317955400593623">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da uključi Bluetooth i učini tablet vidljivim za druge uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="4047444317445386579">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da uključi Bluetooth i učini telefon vidljivim za druge uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="4922952478824372605">"Aplikacija želi da uključi Bluetooth i učini tablet vidljivim za druge uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="1381582950049639439">"Aplikacija želi da uključi Bluetooth i učini telefon vidljivim za druge uređaje. Ovo možete kasnije da promenite u podešavanjima Bluetooth-a."</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Bluetooth se uključuje…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Isključivanje Bluetooth-a…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Zahtev za Bluetooth povezivanje"</string>
    <string name="bluetooth_connection_notif_message" msgid="6087344980352898209">"Dodirnite da biste se povezali sa uređajem „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“."</string>
    <string name="bluetooth_connection_dialog_text" msgid="2537152772549874391">"Da li želite da se povežete sa uređajem „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“?"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Zahtev za pristup telefonskom imeniku"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="7153531868579789993">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi da pristupi kontaktima i istoriji poziva. Želite li da date pristup uređaju <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>?"</string>
    <string name="bluetooth_remember_choice" msgid="173821849670438110">"Ne pitaj ponovo"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2080511174185036562">"Ne pitaj ponovo"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Zahtev za pristup porukama"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="2647611490952377156">"%1$s želi da pristupi porukama. Želite li da odobrite pristup za %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="473439406287008397">"Zahtev za pristup SIM kartici"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="2849083276356078655">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi da pristupa SIM kartici. Odobravanje pristupa SIM kartici će onemogućiti vezu za prenos podataka na uređaju dok traje povezivanje. Dajte pristup uređaju <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Drugim uređajima vidljiv kao „<xliff:g id="DEVICE_NAME">^1</xliff:g>“"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Uključite Bluetooth da biste se povezali sa drugim uređajima."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Uređaji"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Uparite novi uređaj"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3506962706611366830">"Omogućite tabletu da komunicira sa Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2192027516577675587">"Omogućite uređaju da komunicira sa Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="768958961865499804">"Omogućite telefonu da komunicira sa Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Onemogući Bluetooth A2DP hardversko rasterećenje"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="8610420176339657720">"Restartujete uređaj?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8333029144800835996">"Restartujte uređaj da biste promenili ovo podešavanje."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="3488695418187553566">"Restartuj"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="4930826928585464191">"Otkaži"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Medijski uređaji"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Uređaji za pozivanje"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Drugi uređaji"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Sačuvani uređaji"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth će se uključiti radi uparivanja"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Povezivanja"</string>
    <string name="connected_device_previously_connected_title" msgid="605808252622814415">"Prethodno povezani uređaji"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Prethodno povezani"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth je uključen"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Prikaži sve"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum i vreme"</string>
    <string name="choose_timezone" msgid="1450780665958642147">"Izbor vremenske zone"</string>
    <!-- no translation found for intent_sender_data_label (1733806423295725392) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="3202857258557610646">"Pošalji <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="257853357827275530">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="519934560779343541">"Pokreni <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="5087385727740280207">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="36614006839665458">"Nalog:"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proksi"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Obriši"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Proksi port"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Proksi se zaobilazi za"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Vrati na podrazumevano"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Done"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Ime hosta za proksi"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Pažnja"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Potvrdi"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Ime hosta koje ste uneli nije važeće."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Lista izuzimanja koju ste uneli nije ispravno oblikovana. Unesite listu razdvojenu zarezima koja sadrži izuzete domene."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Treba da popunite polje porta."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Polje za port mora da bude prazno ako je polje za naziv hosta prazno."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Uneli ste nevažeći port."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Pregledač koristi HTTP proksi, ali druge aplikacije ne mogu da ga koriste."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"IPv4 imena hosta za pingovanje (www.google.com):"</string>
    <string name="radio_info_ping_hostname_v6" msgid="8327436534663560713">"IPv6 imena hosta za pingovanje (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test za HTTP klijenta:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Pokreni test pingovanja"</string>
    <string name="sdcard_changes_instructions" msgid="2331969501845866957">"Promene će stupiti na snagu kada USB kabl bude ponovo povezan."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="129059989000252994">"Omogući USB masovno skladištenje"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="5298511430610207103">"Ukupno bajtova:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="6189761476582690998">"USB memorija nije priključena."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="6601962586941623203">"Nema SD kartice."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="7721283102767669004">"Dostupni bajtovi:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="4878190674458263222">"USB se koristi kao masovna memorija"</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="8850227049504860012">"SD kartica se koristi kao uređaj za masovno skladištenje."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="1053258530368541571">"Sada možete da uklonite USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="5813940671700138561">"Sada možete bezbedno da uklonite SD karticu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="209564009449909311">"USB memorija je uklonjena tokom korišćenja!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="6817342973919819392">"SD kartica je uklonjena dok je i dalje bila u upotrebi!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="5646588579332741943">"Korišćeni bajtovi:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="8037280964384235345">"Traženje medija u USB memoriji…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="3297316465982471437">"Skeniranje SD kartica za medije…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3444648373391629840">"USB memor. je samo za čitanje."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4338796260718910164">"Postavljena SD kartica je samo za čitanje."</string>
    <string name="skip_label" msgid="6380034601349015895">"Preskoči"</string>
    <string name="next_label" msgid="1248293387735652187">"Dalje"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Jezici"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Ukloni"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Dodajte jezik"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="2845515796732609837">
      <item quantity="one">Želite li da uklonite izabrane jezike?</item>
      <item quantity="few">Želite li da uklonite izabrane jezike?</item>
      <item quantity="other">Želite li da uklonite izabrane jezike?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekst će biti prikazan na nekom drugom jeziku."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Nije moguće ukloniti sve jezike"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Zadržite bar jedan željeni jezik"</string>
    <string name="locale_not_translated" msgid="5079729745235316146">"Možda nije dostupno u nekim aplikacijama"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Premesti nagore"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Premesti nadole"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Premesti na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Premesti na dno"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Ukloni jezik"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Izbor aktivnosti"</string>
    <string name="display_label" msgid="3056320781191343221">"Ekran"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="1850505156136467106">"USB memorija"</string>
    <string name="sd_card_settings_label" product="default" msgid="8715502912796241588">"SD kartica"</string>
    <string name="proxy_settings_label" msgid="6300573815025557843">"Podešavanja za proksi"</string>
    <string name="cancel" msgid="5780102414089664898">"Otkaži"</string>
    <string name="okay" msgid="4827099303045669054">"Potvrdi"</string>
    <string name="forget" msgid="3754013654135912783">"Zaboravi"</string>
    <string name="save" msgid="3125033126936493822">"Sačuvaj"</string>
    <string name="done" msgid="7497982645646431310">"Gotovo"</string>
    <string name="apply" msgid="7834684883190163536">"Primeni"</string>
    <string name="share" msgid="8502235338607613795">"Deli"</string>
    <string name="add" msgid="8335206931421683426">"Dodaj"</string>
    <string name="settings_label" msgid="943294133671632976">"Podešavanja"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Podešavanja"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Prečica podešavanja"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Režim rada u avionu"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bežična veza i mreže"</string>
    <string name="radio_controls_summary" msgid="9028430178697624501">"Upravljanje Wi-Fi mrežom, Bluetooth-om, režimom rada u avionu, mobilnim mrežama i VPN-om"</string>
    <string name="cellular_data_summary" msgid="6551434804367912367">"Omogućava potrošnju podataka na mob. mreži"</string>
    <string name="allow_data_usage_title" msgid="2645963379925196671">"Dozvoli potr. podat. u romingu"</string>
    <string name="roaming" msgid="3055365654530847985">"Roming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Poveži sa uslugom za podatke u romingu"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Poveži sa uslugom za podatke u romingu"</string>
    <string name="roaming_reenable_message" msgid="5150423860521673540">"Veza za prenos podataka je prekinuta zato što ste napustili matičnu mrežu sa isključenim prenosom podataka u romingu."</string>
    <string name="roaming_turn_it_on_button" msgid="6999283810847157816">"Uključi"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Važe naknade za roming."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="5629953315019604726">"Kada omogućite prenos podataka u romingu, važe naknade za roming.\n\nOvo podešavanje utiče na sve korisnike ovog tableta."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="3693719745119874126">"Kada omogućite prenos podataka u romingu, važe naknade za roming.\n\nOvo podešavanje utiče na sve korisnike ovog telefona."</string>
    <string name="roaming_reenable_title" msgid="770824950144026180">"Dozvolite prenos podataka u romingu?"</string>
    <string name="networks" msgid="5184501333492775095">"Izbor operatera"</string>
    <string name="sum_carrier_select" msgid="1669911795517995916">"Izbor mrežnog operatera"</string>
    <string name="date_and_time_settings_title" msgid="2305454529709812364">"Datum i vreme"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="1841717199409629742">"Podešavanje datuma i vremena"</string>
    <string name="date_and_time_settings_summary" msgid="334967758944498010">"Podešavanje datuma, vremena, vremenske zone i formata"</string>
    <string name="date_time_auto" msgid="8227898528525208628">"Koristi vreme mreže"</string>
    <string name="zone_auto_title" msgid="4715775349468228598">"Koristi vremensku zonu mreže"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Koristi podrazumevanu vrednost za lokalitet"</string>
    <string name="date_time_24hour_title" msgid="1445056824481243600">"24-časovni format"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Koristi 24-časovni format"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Vreme"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Format vremena"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Vremenska zona"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Izbor vremenske zone"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Pretražite region"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Region"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Izab. vrem. odstupanje od UTC-a"</string>
    <string name="zone_change_to_from_dst" msgid="686451769985774294">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> počinje <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="7004693956837388129">"Koristi <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> počinje: <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Koristi <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nema letnjeg računanja vremena."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Letnje računanje vremena"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardno vreme"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Izaberite prema regionu"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Izab. prema odstup. od UTC-a"</string>
    <string name="date_picker_title" msgid="646573308567782578">"Datum"</string>
    <string name="time_picker_title" msgid="1784236407401743393">"Vreme"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Zaključaj posle gašenja ekrana"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> posle gašenja ekrana"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Odmah posle gašenja ekrana, osim kada <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> ne dozvoljava zaključavanje"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> posle gašenja ekrana, osim kada <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> sprečava zaključavanje"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="197365342192696406">"Prikaži informacije o vlasniku na zaključ. ekranu"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Dodajte tekst na zaključan ekran"</string>
    <string name="security_enable_widgets_title" msgid="676199714313423099">"Omogući vidžete"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="5191637768484254146">"Administrator je onemogućio"</string>
    <string name="lockdown_settings_title" msgid="8988970335658365075">"Prikaži opciju zaključavanja"</string>
    <string name="lockdown_settings_summary" msgid="7422522013953398806">"Prikaži opciju dugmeta za napajanje koja isključuje Smart Lock, biometrijsko otključavanje i obaveštenja na zaključanom ekranu"</string>
    <string name="trust_lost_locks_screen_title" msgid="4231232144565291276">"Zaključaj ekran kada je agent nepouzdan"</string>
    <string name="trust_lost_locks_screen_summary" msgid="718374221849537361">"Ako se omogući, uređaj će se zaključati kada poslednji pouzdani agent više ne bude pouzdan"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ništa"</string>
    <string name="owner_info_settings_status" msgid="7488764871758677862">"<xliff:g id="COUNT_0">%1$d</xliff:g>/<xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Npr. Jocin Android."</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="5734739022887933365">"Prikaži podatke o profilu na zaključanom ekranu"</string>
    <string name="Accounts_settings_title" msgid="8434263183710375412">"Nalozi"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Lokacija"</string>
    <string name="location_settings_master_switch_title" msgid="4232810467362584112">"Koristi lokaciju"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Isključena"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="1019959038518185676">
      <item quantity="one">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacija ima pristup lokaciji</item>
      <item quantity="few">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacije imaju pristup lokaciji</item>
      <item quantity="other">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacija ima pristup lokaciji</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Učitava se…"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Nalozi"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Bezbednost"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifrovanje i akreditivi"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="5298195959570992363">"Telefon je šifrovan"</string>
    <string name="decryption_settings_summary" product="default" msgid="1742645256103613503">"Telefon nije šifrovan"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="3776741531205406800">"Uređaj je šifrovan"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="1864963068216544631">"Uređaj nije šifrovan"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Zaključani ekran"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Šta se prikazuje"</string>
    <string name="security_settings_summary" msgid="1627059516127354233">"Podešavanje Moje lokacije, otključavanja ekrana, zaključavanja SIM kartice i zaključavanja akreditiva skladišta"</string>
    <string name="cdma_security_settings_summary" msgid="2455517905101186330">"Podešavanje Moje lokacije, otključavanja ekrana, zaključavanja skladišta akreditiva"</string>
    <string name="security_passwords_title" msgid="4154420930973818581">"Privatnost"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nije dostupno"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Bezbednosni status"</string>
    <string name="security_dashboard_summary_face" msgid="4198949293847206382">"Zaključavanje ekrana, otključavanje licem"</string>
    <string name="security_dashboard_summary" msgid="8750183806533140464">"Zaključavanje ekrana, otisak prsta"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="1044589595710115123">"Zaključavanje ekrana"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Lice je dodato"</string>
    <string name="security_settings_face_preference_summary_none" msgid="3758209126322559995">"Podesite otključavanje licem"</string>
    <string name="security_settings_face_preference_title" msgid="821557938243856757">"Otključavanje licem"</string>
    <string name="security_settings_face_profile_preference_title" msgid="4618796080378248740">"Otključavanje licem za posao"</string>
    <string name="security_settings_face_enroll_education_title" msgid="8662585502032112675">"Kako da podesite otključavanje licem"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4632402390714441918">"Podesite otključavanje licem"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Potvrdite identitet licem"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Započnite"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="4681495507974718824">"Ako je otključavanje licem sa funkcijom pristupačnosti isključeno, neki koraci za podešavanje možda neće ispravno raditi sa TalkBack-om."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Nazad"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Nastavite podešavanje"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Koristite podeš. za pristupačn."</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="6763509014732769185"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Otkaži"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Ne, hvala"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="1822303197642630076">"Prihvatam"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Još"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Otključajte pomoću lica"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Potvrdite identitet licem"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="3015751486939484934">"Otključavajte telefon, odobravajte kupovine ili se prijavljujte u aplikacije pomoću lica."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Otključavajte telefon ili odobravajte kupovine pomoću lica.\n\nNapomena: Ne možete da otključavate ovaj uređaj pomoću lica. Više informacija zatražite od administratora organizacije."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Otključavajte telefon, odobravajte kupovine ili se prijavljujte u aplikacije pomoću lica"</string>
    <string name="security_settings_face_enroll_introduction_footer_part_0" msgid="908831787971630413"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="4438129587730915782"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="6099785970191751036"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="8708726599723727710"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Postavite lice u centar kruga"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Preskoči"</string>
    <string name="face_add_max" msgid="4578405795494514876">"Maksimalan broj lica koji možete da dodate je <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Dodali ste maksimalan broj lica"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Ne možete da dodate još lica"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registracija nije završena"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Potvrdi"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Isteklo je vreme za registraciju lica. Probajte ponovo."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Registracija lica nije uspela."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Gotovo. Izgleda da je sve u redu."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Gotovo"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="9080635904939148410">"Poboljšajte učinak otključavanja licem"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="2318506792574194633">"Ponovo podesite otključavanje licem"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="8907917317111783249">"Ponovo podesite otključavanje licem"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Poboljšajte bezbednost i učinak"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="7124713074067550039">"Podesite otključavanje licem"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="950213874209080175">"Izbrišite aktuelne podatke o licu da biste ponovo podesili otključavanje licem.\n\nPodaci o licu koje koristi otključavanje licem biće trajno i bezbedno izbrisani. Posle brisanja trebaće vam PIN, obrazac ili lozinka da biste otključali telefon, prijavljivali se u aplikacije i potvrđivali plaćanja."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="2374998717426341095">"Koristi otklj. licem za"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="5209963876503148501">"Otključavanje telefona"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="8813038341122613020">"Prijavljivanje u aplikacije i plaćanja"</string>
    <string name="security_settings_face_settings_require_category" msgid="3906382658164073665">"Uslovi za otključavanje licem"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Oči moraju da budu otvorene"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Da biste otključali telefon, oči moraju da budu otvorene"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Uvek traži potvrdu"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6454776517804994007">"Uvek zahtevaj potvrdu pri korišćenju otključavanja licem u aplikacijama"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="6491161841504747384">"Briši podatke o licu"</string>
    <string name="security_settings_face_settings_enroll" msgid="4656842124181309056">"Podesite otključavanje licem"</string>
    <string name="security_settings_face_settings_footer" msgid="5545455769328594736">"Otključajte uređaj, prijavite se u aplikaciju i potvrdite plaćanje pomoću otključavanja licem.\n\nImajte u vidu:\nAko pogledate telefon, možete nehotice da ga otključate.\n\nTelefon može da otključa neko drugi ako ga približi vašem licu.\n\nTelefon može da otključa neko ko mnogo liči na vas, na primer, identični blizanac."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="4460565590744451205">"Otključajte uređaj, prijavite se u aplikaciju i potvrdite plaćanje pomoću otključavanja licem.\n\nImajte u vidu:\nAko pogledate telefon, možete nehotice da ga otključate.\n\nTelefon može da otključa neko drugi ako ga približi vašem licu čak i ako su vam oči zatvorene.\n\nTelefon može da otključa neko ko mnogo liči na vas, na primer, identični blizanac."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2596803378375165362">"Brišete podatke o licu?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="3458998128212675289">"Podaci o licu koje koristi otključavanje licem biće trajno i bezbedno izbrisani. Posle uklanjanja trebaće vam PIN, obrazac ili lozinka da biste otključali telefon, prijavljivali se u aplikacije i potvrđivali plaćanja."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="9197485417007952865">"Otključajte telefon licem"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Otisak prsta"</string>
    <string name="fingerprint_manage_category_title" msgid="1249349505688268850">"Upravljaj otis. prstiju"</string>
    <string name="fingerprint_usage_category_title" msgid="8757959085075024856">"Koristi otis. prsta za"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Dodaj otisak prsta"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5451094461919440992">"zaključavanje ekrana"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="988602245530967106">
      <item quantity="one">Podešen je <xliff:g id="COUNT_1">%1$d</xliff:g> otisak prsta </item>
      <item quantity="few">Podešena su <xliff:g id="COUNT_1">%1$d</xliff:g> otiska prstiju</item>
      <item quantity="other">Podešeno je <xliff:g id="COUNT_1">%1$d</xliff:g> otisaka prstiju</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="521797365974277693">"Otključajte otiskom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Koristite otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="242123866344666054">"Samo dodirnite senzor za otisak prsta da biste otključali telefon, ovlastili kupovine ili se prijavili na aplikacije Ovo će biti moguće pomoću svih otisaka prstiju koje dodate, pa budite oprezni koga dodajete.\n\nNapomena: Otisak prsta može da bude manje bezbedan od jakog šablona ili PIN-a."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Otključavajte telefon ili odobravajte kupovine pomoću otiska prsta.\n\nNapomena: Ne možete da otključavate ovaj uređaj pomoću otiska prsta. Više informacija zatražite od administratora organizacije."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="5979556434735281585">"Otključavajte telefon ili odobravajte kupovine pomoću otiska prsta.\n\nNapomena: Otisak prsta može da bude manje bezbedan od jakog šablona ili PIN-a."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="5683573189775460816">"Nastavi"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="370010932190960403">"Preskoči"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="7155412679784724630">"Dalje"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Preskačete otiske prstiju?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Podešavanje otisaka prstiju traje svega minut-dva. Ako preskočite ovo, možete da dodate otisak prsta kasnije u podešavanjima."</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Preskačete zaključavanje ekrana?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1570832293693405757">"Funkcije zaštite uređaja neće biti uključene. Nećete moći da sprečite druge ljude da koriste ovaj tablet ako bude izgubljen, ukraden ili resetovan."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4618501606519351904">"Funkcije zaštite uređaja neće biti uključene. Nećete moći da sprečite druge ljude da koriste ovaj uređaj ako bude izgubljen, ukraden ili resetovan."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2412426429887900241">"Funkcije zaštite uređaja neće biti uključene. Nećete moći da sprečite druge ljude da koriste ovaj telefon ako bude izgubljen, ukraden ili resetovan."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="7119039592587429936">"Funkcije zaštite uređaja neće biti uključene. Nećete moći da sprečite druge ljude da koriste ovaj tablet ako bude izgubljen ili ukraden."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="3365990364131398523">"Funkcije zaštite uređaja neće biti uključene. Nećete moći da sprečite druge ljude da koriste ovaj uređaj ako bude izgubljen ili ukraden."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="4908278819257287536">"Funkcije zaštite uređaja neće biti uključene. Nećete moći da sprečite druge ljude da koriste ovaj telefon ako bude izgubljen ili ukraden."</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Ipak preskoči"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Vrati se"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Preskoči"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dodirnite senzor"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Nalazi se na zadnjoj strani telefona. Koristite kažiprst."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustracija sa uređajem i lokacijom senzora za otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Naziv"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Potvrdi"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Izbriši"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Dodirnite senzor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Stavite prst na senzor i podignite ga kada osetite vibraciju"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Podignite, pa opet dodirnite"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Nastavite da podižete prst da biste dodali različite delove otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Otisak prsta je dodat"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8220458039597261933">"Kada vidite ovu ikonu, koristite otisak prsta radi identifikacije ili odobravanja kupovina"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Uradiću to kasnije"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Preskočiti podešavanje otiska prsta?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Izabrali ste da koristite otisak prsta kao jedan način za otključavanje telefona. Ako sada preskočite, moraćete kasnije da obavite ovo podešavanje. Za podešavanje je potrebno samo oko minut vremena."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="6901147203720764421">"Zaštitite tablet pomoću opcije zaključavanja ekrana da niko ne bi mogao da ga koristi ako ga izgubite ili vam ga ukradu. Opcija zaključavanja ekrana vam treba i da biste podesili otisak prsta. Dodirnite Otkaži, pa podesite PIN, šablon ili lozinku."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="1286244133923093528">"Zaštitite uređaj pomoću opcije zaključavanja ekrana da niko ne bi mogao da ga koristi ako ga izgubite ili vam ga ukradu. Opcija zaključavanja ekrana vam treba i da biste podesili otisak prsta. Dodirnite Otkaži, pa podesite PIN, šablon ili lozinku."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="4810191157587317521">"Zaštitite telefon pomoću opcije zaključavanja ekrana da niko ne bi mogao da ga koristi ako ga izgubite ili vam ga ukradu. Opcija zaključavanja ekrana vam treba i da biste podesili otisak prsta. Dodirnite Otkaži, pa podesite PIN, šablon ili lozinku."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="7387535629289108475">"Zaštitite tablet pomoću opcije zaključavanja ekrana da niko ne bi mogao da ga koristi ako ga izgubite ili vam ga ukradu. Opcija zaključavanja ekrana vam treba i da biste podesili otključavanje licem. Dodirnite Otkaži da biste se vratili."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="4995287019957131123">"Zaštitite uređaj pomoću opcije zaključavanja ekrana da niko ne bi mogao da ga koristi ako ga izgubite ili vam ga ukradu. Opcija zaključavanja ekrana vam treba i da biste podesili otključavanje licem. Dodirnite Otkaži da biste se vratili."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="7086796722966738156">"Zaštitite telefon pomoću opcije zaključavanja ekrana da niko ne bi mogao da ga koristi ako ga izgubite ili vam ga ukradu. Opcija zaključavanja ekrana vam treba i da biste podesili otključavanje licem. Dodirnite Otkaži da biste se vratili."</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Želite li da preskočite podešavanje PIN-a?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Želite li da preskočite podešavanje lozinke?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Želite li da preskočite podešavanje šablona?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Podesi zaključavanje ekrana"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Gotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ups, to nije senzor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Dodirnite senzor na zadnjoj strani telefona. Koristite kažiprst."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="132085362209418770">"Registracija nije završena"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="5479647886550695766">"Vremensko ograničenje za registraciju otiska prsta je isteklo. Probajte ponovo."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"Registracija otiska prsta nije uspela. Probajte ponovo ili koristite drugi prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Dodajte još jedan"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Dalje"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="7875826823637114097">"Osim za otključavanje telefona, otisak prsta možete da koristite i da biste dali ovlašćenje za kupovine i pristup aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="4260983700868889294">" Opcija zaključavanja ekrana je onemogućena. Da biste saznali više, obratite se administratoru organizacije. "<annotation id="admin_details">"Više detalja"</annotation>\n\n"I dalje možete da koristite otisak prsta za odobravanje kupovine i pristupa aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Podignite prst, pa ponovo dodirnite senzor"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Maksimalan broj otisaka prstiju koji možete da dodate je <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste maksimalan broj otisaka prstiju"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Ne možete da dodate još otisaka prstiju"</string>
    <string name="fingerprint_last_delete_title" msgid="4081475675646514726">"Uklanjate sve otiske prstiju?"</string>
    <string name="fingerprint_delete_title" msgid="1469865327307917858">"Uklonite „<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>“"</string>
    <string name="fingerprint_delete_message" msgid="1454995433333496541">"Želite li da izbrišete ovaj otisak prsta?"</string>
    <string name="fingerprint_last_delete_message" msgid="93311579320049852">"Nećete moći da otključavate telefon, odobravate kupovine niti da se prijavljujete u aplikacije pomoću otisaka prstiju"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="3460246522493987163">"Nećete moći da otključavate poslovni profil, odobravate kupovine niti da se prijavljujete u poslovne aplikacije pomoću otisaka prstiju"</string>
    <string name="fingerprint_last_delete_confirm" msgid="3294910995598819259">"Da, ukloni"</string>
    <string name="crypt_keeper_settings_title" msgid="4938812137822100044">"Šifrovanje"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="7484150746479958376">"Šifruj tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="8302873664348463041">"Šifruj telefon"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="3866488451639592071">"Šifrovano"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="4103951371711323192">"Možete da šifrujete naloge, podešavanja, preuzete aplikacije i njihove podatke, medije i druge datoteke. Kada šifrujete tablet, a pod pretpostavkom da ste podesili zaključavanje ekrana (to jest, šablon, numerički PIN ili lozinku), treba da otključate ekran da biste dešifrovali tablet svaki put kada ga uključite. Jedini drugi način da dešifrujete uređaj je da obavite resetovanje na fabrička podešavanja, čime ćete izbrisati sve podatke.\n\nŠifrovanje traje sat vremena ili više. Morate da počnete sa napunjenom baterijom i da ne isključujete tablet iz punjača tokom celog tog procesa. Ako prekinete taj proces, izgubićete sve podatke ili neke od njih."</string>
    <string name="crypt_keeper_desc" product="default" msgid="6180866043921135548">"Možete da šifrujete naloge, podešavanja, preuzete aplikacije i njihove podatke, medije i druge datoteke. Kada šifrujete telefon, a pod pretpostavkom da ste podesili zaključavanje ekrana (to jest, šablon, numerički PIN ili lozinku), treba da otključate ekran da biste dešifrovali telefon svaki put kada ga uključite. Jedini drugi način da dešifrujete uređaj je da obavite resetovanje na fabrička podešavanja, čime ćete izbrisati sve podatke.\n\nŠifrovanje traje sat vremena ili više. Morate da počnete sa napunjenom baterijom i da ne isključujete telefon iz punjača tokom celog tog procesa. Ako prekinete taj proces, izgubićete sve podatke ili neke od njih."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="5551608011810921471">"Šifruj tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="6370330929679426136">"Šifruj telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="4920087247177024521">"Napunite bateriju i pokušajte ponovo."</string>
    <string name="crypt_keeper_unplugged_text" msgid="2709721134148651329">"Uključite punjač i pokušajte ponovo."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="1847280235529858357">"Nema PIN-a ili lozinke za zaključavanje ekrana"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="7210616262954236042">"Potrebno je da podesite PIN ili lozinku za zaključavanje ekrana da biste mogli da započnete šifrovanje."</string>
    <string name="crypt_keeper_confirm_title" msgid="8600000209722452230">"Želite li da šifrujete?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="3270587498436152259">"Operacija šifrovanja je neopoziva i ukoliko je prekinete, izgubićete podatke. Šifrovanje traje jedan sat ili duže i u tom periodu tablet će se ponovo pokrenuti nekoliko puta."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="3040428543349852419">"Operacija šifrovanja je neopoziva i ukoliko je prekinete, izgubićete podatke. Šifrovanje traje jedan sat ili duže i u tom periodu telefon će se ponovo pokrenuti nekoliko puta."</string>
    <string name="crypt_keeper_setup_title" msgid="3339725741305796680">"Šifrovanje"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="4417016995091289019">"Sačekajte da se tablet šifruje. Dovršeno je <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="7902355422499500352">"Sačekajte da se telefon šifruje. Dovršeno je <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="8348188415839917821">"Sačekajte dok se tablet šifruje. Preostalo vreme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="8556105766597855198">"Sačekajte dok se telefon šifruje. Preostalo vreme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="3832496715430327682">"Da biste otključali tablet, isključite ga, pa ga ponovo uključite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="5070346039522135361">"Da biste otključali telefon, isključite ga, pa ga ponovo uključite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="8104921337301750394">"Upozorenje: Podaci sa uređaja će biti obrisani ako ne uspete da ga otključate još <xliff:g id="COUNT">^1</xliff:g> puta!"</string>
    <string name="crypt_keeper_enter_password" msgid="1274917431075529732">"Unesite lozinku"</string>
    <string name="crypt_keeper_failed_title" msgid="8173654570682244149">"Šifrovanje nije uspelo"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="5977961188966570342">"Šifrovanje je prekinuto i ne može da se dovrši. Kao posledica toga, podaci na tabletu više nisu dostupni. \n\n Da biste nastavili da koristite tablet, treba da ga resetujete. Kada ga podesite nakon resetovanja na fabrička podešavanja, imaćete priliku da vratite sve podatke za koje ste napravili rezervne kopije na Google nalogu."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="1028716993071131029">"Šifrovanje je prekinuto i ne može da se dovrši. Kao posledica toga, podaci na telefonu više nisu dostupni. \n\nDa biste nastavili da koristite telefon, treba da ga resetujete. Kada ga podesite nakon resetovanja na fabrička podešavanja, imaćete priliku da vratite sve podatke za koje ste napravili rezervne kopije na Google nalogu."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="5920153462176846037">"Dešifrovanje nije uspelo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="4420666705959562753">"Lozinka koju ste uneli je tačna, ali, nažalost, podaci su oštećeni. \n\nDa biste nastavili da koristite tablet, treba da obavite resetovanje na fabrička podešavanja. Tokom podešavanja tableta posle resetovanja moći ćete da vratite sve podatke čija rezervna kopija postoji na Google nalogu."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="3200498792238652367">"Lozinka koju ste uneli je tačna, ali, nažalost, podaci su oštećeni. \n\nDa biste nastavili da koristite telefon, treba da obavite resetovanje na fabrička podešavanja. Tokom podešavanja telefona posle resetovanja moći ćete da vratite sve podatke čija rezervna kopija postoji na Google nalogu."</string>
    <string name="crypt_keeper_switch_input_method" msgid="7712732134989470573">"Prebaci metode unosa"</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Zaštitite telefon"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="3213718550422761562">"Podesite zaključavanje ekrana da biste zaštitili tablet"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="8479766049078378225">"Podesite zaključavanje ekrana da biste zaštitili uređaj"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="2443273582716671033">"Podesite zaključavanje ekrana da biste zaštitili telefon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Dodajte otisak prsta za otključavanje"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="1040265358906410746"></string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Zaključavanje ekrana"</string>
    <string name="lock_settings_picker_title_profile" msgid="8377696902400733227">"Izaberite zaključavanje za posao"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="1276283007274778191">"Zaštitite tablet"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="3585905639045649905">"Zaštitite uređaj"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="2758197863515864300">"Zaštitite telefon"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Radi dodatne bezbednosti podesite rezervni način zaključavanja ekrana"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="4870877800737248926">"Sprečite druge da koriste ovaj tablet bez dozvole tako što ćete aktivirati funkcije zaštite uređaja. Izaberite zaključavanje ekrana koje želite da koristite."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="8961855222808442301">"Sprečite druge da koriste ovaj uređaj bez dozvole tako što ćete aktivirati funkcije zaštite uređaja. Izaberite zaključavanje ekrana koje želite da koristite."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="8867435145945818970">"Sprečite druge da koriste ovaj telefon bez dozvole tako što ćete aktivirati funkcije zaštite uređaja. Izaberite zaključavanje ekrana koje želite da koristite."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="6414674538453498900">"Izaberite rezervni način za zaključavanje ekrana"</string>
    <string name="lock_settings_picker_face_message" msgid="2044129433641084149">"Izaberite rezervni način za zaključavanje ekrana"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opcije zaključavanja ekrana"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opcije zaključavanja ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5799070517574360310">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g>/odmah posle spavanja"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4572132216801894216">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g>/<xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> posle spavanja"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zaključavanje poslovnog profila"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="4746783679112447948">"Promena zaključ. ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="6023813780512501969">"Menjanje ili onemogućavanje šablona, PIN koda ili bezbednosti lozinke"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="1699993191343299179">"Izaberite metod zaključavanja ekrana"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ništa"</string>
    <string name="unlock_set_unlock_off_summary" msgid="4578319976164001322"></string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Prevlačenje"</string>
    <string name="unlock_set_unlock_none_summary" msgid="641298008390890152">"Nema bezbednosti"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Šablon"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="4482018884090552709">"Srednji nivo bezbednosti"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="1961863114590024945">"Srednji do visokog nivoa bezbednosti"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Lozinka"</string>
    <string name="unlock_set_unlock_password_summary" msgid="7647435233968707432">"Visok nivo bezbednosti"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ne sada"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Aktuelno zaključavanje ekrana"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"otisak prsta + šablon"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"otisak prsta + PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"otisak prsta + lozinka"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Nastavite bez otiska prsta"</string>
    <string name="fingerprint_unlock_title" msgid="4978686534505944042">"Možete da otključate telefon pomoću otiska prsta. Ova opcija zahteva rezervni metod zaključavanja ekrana iz bezbednosnih razloga."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="5991691559532427891">"Otključavanje licem + šablon"</string>
    <string name="face_unlock_set_unlock_pin" msgid="8990569318587034610">"Otključavanje licem + PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8612535943511761549">"Otključavanje licem + lozinka"</string>
    <string name="face_unlock_skip_face" msgid="7117201898540606846">"Nastavite bez otključavanja licem"</string>
    <string name="face_unlock_title" msgid="7344830351598247267">"Možete da otključate telefon pomoću lica. Ova opcija zahteva rezervni metod zaključavanja ekrana iz bezbednosnih razloga."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="4022867760387966129">"Onemogućio administrator, smernice za šifrovanje ili skladište akreditiva"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ništa"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Prevucite"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Šablon"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Lozinka"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="5974580769186206478">"Kada podesite zaključavanje ekrana, možete da podesite i otisak prsta u Podešavanjima &gt; Bezbednost."</string>
    <string name="unlock_disable_lock_title" msgid="2564279819907932759">"Isključivanje zaključavanja ekrana"</string>
    <string name="unlock_disable_frp_warning_title" msgid="1520689401825045809">"Želite li da uklonite zaštitu uređaja?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Želite li da uklonite zaštitu profila?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="669384600341275312">"Funkcije za zaštitu uređaja neće funkcionisati bez šablona."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="8160948976853039106">"Funkcije zaštite uređaja neće raditi bez šablona.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog uređaja, a vi nećete moći da otključavate telefon, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="3732073290049930632">"Funkcije za zaštitu uređaja neće funkcionisati bez PIN-a."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="2018020861756931097">"Funkcije zaštite uređaja neće raditi bez PIN-a.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog uređaja, a vi nećete moći da otključavate telefon, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="2130004168084396797">"Funkcije za zaštitu uređaja neće funkcionisati bez lozinke."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8455564842615579472">"Funkcije zaštite uređaja neće raditi bez lozinke.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog uređaja, a vi nećete moći da otključavate telefon, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funkcije za zaštitu uređaja neće funkcionisati bez zaključavanja ekrana."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="4985095359625056279">"Funkcije zaštite uređaja neće raditi bez zaključavanja ekrana.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog uređaja, a vi nećete moći da otključavate telefon, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="6850770024037691891">"Funkcije zaštite profila neće funkcionisati bez šablona."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="313998125412427527">"Funkcije zaštite profila neće raditi bez šablona.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog profila, a vi nećete moći da otključavate profil, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="6328378875803145738">"Funkcije zaštite profila neće funkcionisati bez PIN-a."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="6844729803535310058">"Funkcije zaštite profila neće raditi bez PIN-a.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog profila, a vi nećete moći da otključavate profil, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="6922335143823758149">"Funkcije zaštite profila neće funkcionisati bez lozinke."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="5724824564583660260">"Funkcije zaštite profila neće raditi bez lozinke.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog profila, a vi nećete moći da otključavate profil, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6886183964362015704">"Funkcije zaštite profila neće funkcionisati bez zaključavanja ekrana."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="3754195701700959477">"Funkcije zaštite profila neće raditi bez zaključavanja ekrana.<xliff:g id="EMPTY_LINE">

</xliff:g>Sačuvani otisci prstiju će takođe biti uklonjeni sa ovog profila, a vi nećete moći da otključavate profil, da odobravate kupovine niti da se prijavljujete u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="621607297961726537">"Da, ukloni"</string>
    <string name="unlock_change_lock_pattern_title" msgid="8234523589333929193">"Promena šablona za otključavanje"</string>
    <string name="unlock_change_lock_pin_title" msgid="2324077520816477479">"Promena PIN-a za otključavanje"</string>
    <string name="unlock_change_lock_password_title" msgid="873517913969091074">"Promena lozinke za otključavanje"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje jak PIN ili lozinku i možda neće raditi na očekivani način ako to ne podesite"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje novi PIN ili lozinku i možda neće raditi na očekivani način ako to ne podesite"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje novi šablon, PIN ili lozinku i možda neće raditi na očekivani način ako to ne podesite"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> preporučuje novo zaključavanje ekrana"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Probajte ponovo. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. pokušaj od <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Izbrisaćemo podatke"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ako u sledećem pokušaju unesete netačan šablon, izbrisaćemo podatke sa ovog uređaja"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ako u sledećem pokušaju unesete netačan PIN, izbrisaćemo podatke sa ovog uređaja"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ako unesete netačnu lozinku pri sledećem pokušaju, izbrisaćemo podatke sa ovog uređaja"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ako u sledećem pokušaju unesete netačan šablon, izbrisaćemo ovog korisnika"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ako u sledećem pokušaju unesete netačan PIN, izbrisaćemo ovog korisnika"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ako u sledećem pokušaju unesete netačnu lozinku, izbrisaćemo ovog korisnika"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ako u sledećem pokušaju unesete netačan šablon, izbrisaćemo poslovni profil i njegove podatke"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ako u sledećem pokušaju unesete netačan PIN, izbrisaćemo poslovni profil i njegove podatke"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ako u sledećem pokušaju unesete netačnu lozinku, izbrisaćemo poslovni profil i njegove podatke"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="2813744895409014471">"Previše netačnih pokušaja. Izbrisaćemo podatke sa ovog uređaja."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="3958755474620948727">"Previše netačnih pokušaja. Izbrisaćemo ovog korisnika."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="3171880997211568208">"Previše netačnih pokušaja. Izbrisaćemo ovaj poslovni profil i njegove podatke."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="170155081899679669">"Odbaci"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="2192234965414232157">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT_1">%d</xliff:g> znak</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT_1">%d</xliff:g> znaka</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT_1">%d</xliff:g> znakova</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="6817086810898414162">
      <item quantity="one">PIN mora da sadrži najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifru</item>
      <item quantity="few">PIN mora da sadrži najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifre</item>
      <item quantity="other">PIN mora da sadrži najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifara</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="2507983991979547816">"Nastavi"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="8118091957172967677">
      <item quantity="one">Mora da sadrži manje od <xliff:g id="NUMBER_1">%d</xliff:g> znaka</item>
      <item quantity="few">Mora da sadrži manje od <xliff:g id="NUMBER_1">%d</xliff:g> znaka</item>
      <item quantity="other">Mora da sadrži manje od <xliff:g id="NUMBER_1">%d</xliff:g> znakova</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="8706992338720310765">
      <item quantity="one">Mora da sadrži manje od <xliff:g id="NUMBER_1">%d</xliff:g> cifre</item>
      <item quantity="few">Mora da sadrži manje od <xliff:g id="NUMBER_1">%d</xliff:g> cifre</item>
      <item quantity="other">Mora da sadrži manje od <xliff:g id="NUMBER_1">%d</xliff:g> cifara</item>
    </plurals>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Administrator uređaja ne dozvoljava upotrebu nedavno korišćenog PIN-a"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="115994274880232984">"IT administrator blokira česte PIN-ove. Izaberite drugi PIN."</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Ne sme da obuhvata nevažeći znak"</string>
    <string name="lockpassword_password_requires_alpha" msgid="721084100957669018">"Mora da sadrži najmanje jedno slovo"</string>
    <string name="lockpassword_password_requires_digit" msgid="312518567592683795">"Mora da sadrži najmanje jednu cifru"</string>
    <string name="lockpassword_password_requires_symbol" msgid="6178512486154701321">"Mora da sadrži najmanje jedan simbol"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="2385916409676839024">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> slovo</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> slova</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2057467885488612701">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> malo slovo</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> mala slova</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> malih slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="4541266279643052025">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> veliko slovo</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> velika slova</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> velikih slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="70617964591376248">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> cifru</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> cifre</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> cifara</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="7981236881269921943">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> specijalni simbol</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> specijalna simbola</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> specijalnih simbola</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="1567877061888948467">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> znak koji nije slovo</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> znaka koji nisu slova</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> znakova koji nisu slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonnumerical" formatted="false" msgid="5056743974888384475">
      <item quantity="one">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> znak koji nije broj</item>
      <item quantity="few">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> znaka koji nisu brojevi</item>
      <item quantity="other">Mora da sadrži najmanje <xliff:g id="COUNT">%d</xliff:g> znakova koji nisu brojevi</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Administrator uređaja ne dozvoljava upotrebu nedavno korišćene lozinke"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="8956110268546396737">"IT administrator blokira česte lozinke. Izaberite drugu lozinku."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Rastući, opadajući ili ponovljeni niz cifara nije dozvoljen"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potvrdi"</string>
    <string name="lockpassword_cancel_label" msgid="6711112212489992112">"Otkaži"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Obriši"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zaključavanje ekrana je već promenjeno. Probajte ponovo sa novim zaključavanjem ekrana."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Otkaži"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Dalje"</string>
    <string name="lock_setup" msgid="4622999020926280737">"Podešavanje je dovršeno."</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apl. za administratora uređaja"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Nema aktivnih aplikacija"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="2528735319390151989">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aktivna aplikacija</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aktivne aplikacije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aktivnih aplikacija</item>
    </plurals>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Pouzdani agenti"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Da biste ovo koristili, prvo podesite zaključavanje ekrana"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Ništa"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="5438047398376802735">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aktivan pouzdani agent</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aktivna pouzdana agenta</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktivnih pouzdanih agenata</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="5955341060378240781">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5257744297562880017">"Uključi Bluetooth"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="6805458703566046784">"Upravljanje vezama, podešavanje naziva i vidljivosti uređaja"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Želite da uparite sa <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Kôd za uparivanje sa Bluetooth uređajem"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Unesite kôd za uparivanje, pa pritisnite Return ili Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN sadrži slova ili simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Obično 0000 ili 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Mora da sadrži 16 cifara"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Možda će biti potrebno da unesete ovaj PIN i na drugom uređaju."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Možda će biti potrebno da unesete ovaj pristupni kôd i na drugom uređaju."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="327192310468680072">"Da biste se uparili sa uređajem:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Uverite 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="1068123527866596779">"Sa uređaja:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Želite li da se uparite sa tim uređajem?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="8672803845151786521">"Za uparivanje sa 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>Unesite na njemu:<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>, a zatim pritisnite Return ili Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Dozvolite pristup kontaktima i istoriji poziva"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nije moguće povezati se sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="3460316252463771851">"Skeniranje za uređaje"</string>
    <string name="bluetooth_search_for_devices" msgid="6516902340975407648">"Osveži"</string>
    <string name="bluetooth_searching_for_devices" msgid="6541984133657573124">"Pretražuje se…"</string>
    <string name="bluetooth_preference_device_settings" msgid="1688662188157019998">"Podešavanja uređaja"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="1090131276572055841">"Upareni uređaj"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="4337953030661626289">"Internet veza"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="8247634441638919886">"Tastatura"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="8194423860397844579">"Kontakti i istorija poziva"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="6106058683134173178">"Želite uparivanje sa ovim uređajem?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="5472835166206721325">"Želite li da delite telefonski imenik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="7516277926581535299">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi da pristupa kontaktima i istoriji poziva."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="1545098121090892788">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi da se upari pomoću Bluetooth-a. Kada se poveže, imaće pristup kontaktima i istoriji poziva."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dostupni uređaji"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="1331122763066030155">"Nije dostupan nijedan uređaj"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Poveži"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Prekini vezu"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Upari i poveži"</string>
    <string name="bluetooth_device_context_unpair" msgid="7525735305244087162">"Opozovi uparivanje"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="2001359431289794561">"Prekini vezu i uparivanje"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="934657460643490773">"Opcije…"</string>
    <string name="bluetooth_menu_advanced" msgid="7633682234855216066">"Napredna podešavanja"</string>
    <string name="bluetooth_advanced_titlebar" msgid="5369701494951467257">"Napredni Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Kada je Bluetooth uključen, uređaj može da komunicira sa drugim Bluetooth uređajima u blizini."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="4069064120315578780">"Dok je Bluetooth uključen, uređaj može da komunicira sa drugim Bluetooth uređajima u blizini.\n\nRadi boljeg doživljaja na uređaju, aplikacije i usluge i dalje mogu u bilo kom trenutku da traže uređaje u blizini, čak i kada je Bluetooth isključen. Ovo može da se koristi, na primer, za poboljšanje funkcija i usluga zasnovanih na lokaciji. To možete da promenite u "<annotation id="link">"podešavanjima skeniranja"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1358879010396045164">"Da bi poboljšale tačnost lokacije, sistemske aplikacije i usluge će i dalje prepoznavati Bluetooth uređaje, čak i kada je Bluetooth isključen. Ovo možete da promenite u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>podešavanjima skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="7892663424429584925">"Povezivanje nije uspelo. Pokušajte ponovo."</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detalji o uređaju"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Bluetooth adresa uređaja: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Želite li da zaboravite uređaj?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="4730377171981539265">"Telefon neće više biti uparen sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="3428463407231980054">"Tablet neće više biti uparen sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="5117397433721336918">"Uređaj neće više biti uparen sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="1938465582242297905">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> više neće biti uparen ni sa jednim uređajem povezanim sa ovim nalogom"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Zaboravi uređaj"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="1323072239637864488">"Povezivanje sa…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="339103864166293612">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g>neće biti povezan na zvuka medija."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="7857706184371154920">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> neće biti povezan na hendsfri zvuk."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="4794752406024916925">"Uređaj  <xliff:g id="DEVICE_NAME">%1$s</xliff:g> neće biti povezan na ulaznoi uređaj."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="283176886159444413">"Pristup Internetu preko uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> biće onemogućen."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="733193449967330892">"Deljenje internet veze sa ovim tabletom biće prekinuto za uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="7852265676243153982">"Deljenje internet veze sa ovim telefonom biće prekinuto za uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_device_advanced_title" msgid="1181664272013729515">"Upareni Bluetooth uređaj"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="8302236592496988747">"Poveži"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="271856759516576615">"Povezivanje sa Bluetooth uređajem"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="7892879890208207223">"Koristite za"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="4798081898389041132">"Preimenovanje"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="7604726126703453984">"Dozv. sve dolaz. prenose dat."</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="7851033200857999275">"Povezano je sa uređajem radi pristupa internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="5563892893331988809">"Lokalna internet veza se deli sa uređajem"</string>
    <string name="bluetooth_dock_settings" msgid="1709536202189755022">"Podešavanja bazne stanice"</string>
    <string name="bluetooth_dock_settings_title" msgid="4872789068019972847">"Korišćenje postolja za zvuk"</string>
    <string name="bluetooth_dock_settings_headset" msgid="5756482379574272554">"Kao zvučnik telefona"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="434520221656010141">"Za muziku i medije"</string>
    <string name="bluetooth_dock_settings_remember" msgid="6993526033095292609">"Zapamti podešavanja"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimalan broj povezanih Bluetooth audio uređaja"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Izaberite maksimalni broj povezanih Bluetooth audio uređaja"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Prebacivanje"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"preslikati"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Omogući bežični prikaz"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Nema uređaja u blizini."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Povezivanje"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Povezan"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"U upotrebi"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nedostupan"</string>
    <string name="wifi_display_details" msgid="2351632307998142920">"Podešavanja ekrana"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opcije bežičnog ekrana"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Zaboravi"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Naziv"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Prijavi me"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Otvori sajt"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Još <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Ističe <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_tap_to_sign_in" msgid="8658506618807549483">"Dodirnite ovde da biste se prijavili na mrežu"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> želi da uključi Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> želi da isključi Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Potvrdi binarni kôd aplikacija iz kojih mogu da se otklone greške"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Dozvoli da ART potvrdi binarni kôd aplikacija iz kojih mogu da se otklone greške"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Prikaži učestalost osvežavanja"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Prikaži aktuelnu učestalost osvežavanja ekrana"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="3622326550467939809">"Dozvolite razmenu podataka kada tablet dodirne NFC uređaj"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="1460871052409162980">"Dozvolite razmenu podataka kada telefon dodirne NFC uređaj"</string>
    <string name="nfc_disclaimer_title" msgid="3696580694485048039">"Uključite NFC"</string>
    <string name="nfc_disclaimer_content" msgid="8256675597551036207">"NFC razmenjuje podatke između ovog uređaja i drugih obližnjih uređaja ili meta, poput terminala za plaćanje, čitača za kontrolu pristupa i interaktivnih oglasa ili oznaka."</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Za korišćenje NFC-a mora da se otključa uređaj"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="4591286109299690373">"Dozvoli korišćenje NFC opcija za plaćanje i javni prevoz samo kada je ekran otključan"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Spremno za prenos sadržaja aplikacija preko NFC-a"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Isključeno"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nije dostupno zato što je NFC isključen"</string>
    <string name="android_beam_label" msgid="7168565080321110094">"Android Beam"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Kada je ova funkcija uključena, možete da prebacujete sadržaj aplikacija na drugi uređaj na kome je omogućen NFC tako što ćete približiti uređaje jedan drugome. Na primer, možete da prebacujete veb-stranice, YouTube video snimke, kontakte i još toga.\n\nSamo prislonite uređaje jedan na drugi (obično sa zadnje strane), a zatim dodirnite ekran. Aplikacija određuje šta će biti prebačeno."</string>
    <string name="wifi_quick_toggle_title" msgid="2737097538432862807">"Wi‑Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="4957267477820468553">"Uključivanje Wi-Fi-ja"</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi‑Fi"</string>
    <string name="wifi_settings_master_switch_title" msgid="6043556596728888">"Koristi Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Wi-Fi podešavanja"</string>
    <string name="wifi_settings_title" msgid="3879649725059512799">"Wi‑Fi"</string>
    <string name="wifi_settings_summary" msgid="784074686763572811">"Podešavanje i upravljanje bežičnim pristupnim tačkama"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Izaberi Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Uključivanje Wi-Fi-ja..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Isključivanje Wi-Fi-ja..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Greška"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Opseg od 5 GHz nije dostupan u ovoj zemlji"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"U Režimu rada u avionu"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Obavesti me o javnim mrežama"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Obavesti me kad god je dostupna javna mreža visokog kvaliteta"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Automatski uključi Wi‑Fi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi‑Fi će se ponovo uključiti u blizini sačuvanih mreža visokog kvaliteta, kao što je kućna mreža"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nije dostupno jer je lokacija isključena. Uključite "<annotation id="link">"lokaciju"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="1771489741850119751">"Nedostupno je jer je isključeno Wi‑Fi skeniranje"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="3615120120960539780">"Da biste koristili funkciju, izaberite dobavljača ocene mreže"</string>
    <string name="wifi_poor_network_detection" msgid="8210035875160288422">"Izbegavaj loše veze"</string>
    <string name="wifi_poor_network_detection_summary" msgid="383834617032605347">"Ne koristi Wi-Fi mrežu ako nema dobru internet vezu"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4993203473116721772">"Koristi samo one mreže koje imaju dobru internet vezu"</string>
    <string name="use_open_wifi_automatically_title" msgid="7193846454986712009">"Poveži na javne mreže"</string>
    <string name="use_open_wifi_automatically_summary" msgid="6663890845558591023">"Automatski se povezuj sa javnim mrežama visokog kvaliteta"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="2299284032301667622">"Da biste koristili funkciju, izaberite dobavljača ocene mreže"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="1780306481499369913">"Da biste koristili funkciju, izaberite kompatibilnog dobavljača ocene mreže"</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instaliraj sertifikate"</string>
    <string name="wifi_scan_notify_text" msgid="2518097467707535013">"Da bi poboljšale preciznost lokacije, aplikacije i usluge mogu i dalje da traže Wi‑Fi mreže u bilo kom trenutku, čak i kada je Wi‑Fi isključen. Ovo može da se koristi, na primer, za poboljšanje funkcija i usluga zasnovanih na lokaciji. Ovo možete da promenite u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>podešavanjima pretraživanja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="6189528915806353667">"Da biste poboljšali preciznost lokacije, uključite Wi-Fi skeniranje u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>podešavanjima skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="8436897497968907701">"Ne prikazuj ponovo"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="6285374200292675649">"Ne isključuj Wi-Fi tokom spavanja"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8753852404141070878">"Wi‑Fi je uključen tokom spavanja"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="4512566787805720422">"Došlo je do problema prilikom promene podešavanja"</string>
    <string name="wifi_suspend_efficiency_title" msgid="3589291227092825754">"Poboljšaj efikasnost"</string>
    <string name="wifi_suspend_optimizations" msgid="5840680940416640209">"Wi-Fi optimizacija"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="8204170804523356781">"Smanji korišćenje baterije kada je Wi-Fi uključen"</string>
    <string name="wifi_limit_optimizations_summary" msgid="8461087338100462302">"Ogran. bat. koju koristi Wi-Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="681353878530696197">"Pređi na mobilne podatke ako Wi‑Fi izgubi pristup internetu."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automatski pređi na mobilne podatke"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Koristite mobilne podatke kada Wi‑Fi nema pristup internetu. Može da vam bude naplaćena potrošnja podataka."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Dodaj mrežu"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Podešavanja Wi‑Fi-ja"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi se automatski uključuje ponovo"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi se ne uključuje ponovo automatski"</string>
    <string name="wifi_access_points" msgid="5846755709207101844">"Wi-Fi mreže"</string>
    <string name="wifi_menu_more_options" msgid="1236651929987819716">"Još opcija"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="3498653582115656526">"Skeniraj"</string>
    <string name="wifi_menu_advanced" msgid="1940919392030994019">"Napredno"</string>
    <string name="wifi_menu_configure" msgid="352423980467311427">"Konfiguriši"</string>
    <string name="wifi_menu_connect" msgid="7824796427932811078">"Poveži sa mrežom"</string>
    <string name="wifi_menu_remember" msgid="8639523871321603112">"Zapamti mrežu"</string>
    <string name="wifi_menu_forget" msgid="6557142984528657361">"Zaboravi mrežu"</string>
    <string name="wifi_menu_modify" msgid="7246143391161038875">"Izmeni mrežu"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Da biste videli dostupne mreže, uključite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="5043989454000825717">"Traže se Wi-Fi mreže..."</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nemate dozvolu da menjate Wi‑Fi mrežu."</string>
    <string name="wifi_more" msgid="8742256421693351035">"Još"</string>
    <string name="wifi_setup_wps" msgid="4303694722593999931">"Automatsko podešavanje (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Želite da uključite Wi-Fi skeniranje?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Da bi se automatski uključivao Wi‑Fi, prvo treba da uključite Wi‑Fi skeniranje."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Wi-Fi skeniranje omogućava aplikacijama i uslugama da traže Wi‑Fi mreže u bilo kom trenutku, čak i kada je Wi‑Fi isključen. Ovo, na primer, može da se koristi za poboljšanje funkcija i usluga zasnovanih na lokaciji."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Uključi"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Wi‑Fi skeniranje je uključeno"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Napredne opcije"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Padajuća lista sa naprednim opcijama"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"proširite"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Ime mreže"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Unesite SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Bezbednost"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skrivena mreža"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Ako ruter ne emituje ID mreže, ali želite da ga povežete na mrežu u budućnosti, možete da podesite mrežu tako da bude sakrivena.\n\nTo može da dovede do bezbednosnog rizika jer telefon redovno emituje signal da bi pronašao mrežu.\n\nPodešavanje mreže tako da bude sakrivena ne menja podešavanja rutera."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Jačina signala"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Brzina linka za prenos"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Brzina linka za prijem"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Brzina veze"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvencija"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP adresa"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Sačuvano preko"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Akreditiv za <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP metod"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Potvrda identiteta druge faze"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA sertifikat"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Status onlajn sertifikata"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domen"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Korisnički sertifikat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identitet"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonimni identitet"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Lozinka"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Prikaži lozinku"</string>
    <string name="wifi_ap_band_config" msgid="1589020070150933055">"Izaberite opseg pristupne tačke"</string>
    <string name="wifi_ap_choose_auto" msgid="8944442003151215691">"Automatski"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Opseg od 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8413248472288180075">"Opseg od 5,0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Prednost ima opseg od 5,0 GHz"</string>
    <string name="wifi_ap_2G" msgid="4099628221864343015">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="3493942667238551207">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="5221193733812493435">"Izaberite barem jedan opseg za Wi‑Fi hotspot:"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP podešavanja"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privatnost"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Pretplata"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Pregledajte ili promenite pretplatu"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Nasumično izabrani MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Dodaj uređaj"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centrirajte QR kôd ispod da biste dodali uređaj na mrežu „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Skeniraj QR kôd"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Postavite QR kôd u nastavku da biste dodali uređaj na mrežu „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Povežite se na Wi‑Fi mrežu tako što ćete skenirati QR kôd"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Deli Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="4405316188694088689">"Skenirajte ovaj QR kôd da biste se povezali sa „<xliff:g id="SSID">%1$s</xliff:g>“ i delili lozinku"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Skenirajte ovaj QR kôd da biste se pridružili mreži „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Probajte ponovo. Ako se problem nastavi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Došlo je do greške"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Uverite se da je uređaj priključen na struju, napunjen i uključen"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Uverite se da je uređaj priključen na struju, napunjen i uključen. Ako se problem nastavi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Ovaj uređaj ne podržava dodavanje mreže „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Probajte da približite uređaj Wi‑Fi pristupnoj tački/ruteru"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Proverite lozinku i probajte ponovo"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Obratite se proizvođaču uređaja"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Proverite vezu i probajte ponovo"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Odaberite mrežu"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Da biste povezali uređaj, odaberite mrežu"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Želite li da dodate ovaj uređaj na mrežu „<xliff:g id="SSID">%1$s</xliff:g>“?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi se deli sa uređajem"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Dodaj još jedan uređaj"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Odaberi drugu mrežu"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Dodavanje uređaja nije uspelo"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Pronađen je uređaj"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Deli se Wi‑Fi sa ovim uređajem…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Povezuje se…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Delite hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Potvrdite svoj identitet"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Lozinka za Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Lozinka hotspota: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatsko povezivanje"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Dozvolite povezivanje sa ovom mrežom kada je uređaj u dometu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Dodaj uređaj"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Koristite QR kôd da biste dodali uređaj na ovu mrežu"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR kôd nije u važećem formatu"</string>
    <string name="retry" msgid="7542103800274026915">"Probaj ponovo"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Deli sa drugim korisnicima uređaja"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nepromenjeno)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Izaberite"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Dodato je više sertifikata)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Koristi sertifikate sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ne pružaj"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4673867078988209732">"Ne proveravaj"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Naziv mreže je predugačak."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Morate da navedete domen."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Sertifikat je obavezan."</string>
    <string name="wifi_wps_available_first_item" msgid="5780501151792036589">"WPS je dostupan"</string>
    <string name="wifi_wps_available_second_item" msgid="1717024103303480804">" (WPS je dostupan)"</string>
    <string name="wifi_carrier_connect" msgid="4511538300946413213">"Wi‑Fi mreža mobilnog operatera"</string>
    <string name="wifi_carrier_content" msgid="2876499905644083615">"Povežite se preko <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Zbog poboljšanja preciznosti lokacije i u druge svrhe, <xliff:g id="APP_NAME">%1$s</xliff:g> želi da uključi skeniranje mreže čak i kada je Wi-Fi isključen.\n\nŽelite li da dozvolite ovo za sve aplikacije koje žele da skeniraju?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Radi poboljšanja preciznosti lokacije i u druge svrhe, nepoznata aplikacija želi da uključi skeniranje mreže čak i kada je Wi-Fi isključen.\n\nŽelite da dozvolite ovo za sve aplikacije koje žele da skeniraju?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="93691286302680448">"Da biste ovo isključili, idite na Napredno u preklopnom meniju."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Dozvoli"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Odbij"</string>
    <string name="wifi_hotspot_title" msgid="1918712370697971229">"Želite li da se prijavite radi povezivanja?"</string>
    <string name="wifi_hotspot_message" msgid="5245614124614833169">"<xliff:g id="APP_NAME">%1$s</xliff:g> zahteva da se prijavite onlajn radi povezivanja sa mrežom."</string>
    <string name="wifi_hotspot_connect" msgid="1916314048788438331">"POVEŽI SE"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Ova mreža nema pristup internetu. Želite li da ostanete povezani?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Neke aplikacije i usluge neće raditi usled ograničene veze. Želite li da se ipak koristi?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ne pitaj ponovo za ovu mrežu"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi‑Fi mreža nije povezana na internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Možete da pređete na mobilnu mrežu kad god je Wi‑Fi veza loša. Može da vam bude naplaćena potrošnja podataka."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Pređi na mobilne podatke"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Ostani na Wi‑Fi-ju"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Ne prikazuj ponovo"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Poveži"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi je uključen"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Povezano je na mrežu <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Povezuje se…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Povezivanje sa mrežom nije uspelo"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Mreža nije u dometu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Zaboravi"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Izmeni"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Brisanje mreže nije uspelo"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Sačuvaj"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Čuvanje mreže nije uspelo"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Otkaži"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Želite li da uređaj zaboravi mrežu?"</string>
    <string name="wifi_forget_dialog_message" msgid="8419499588321940243">"Sve lozinke za ovu mrežu će biti izbrisane"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="2802436466732147888">
      <item quantity="one">%d mreža</item>
      <item quantity="few">%d mreže</item>
      <item quantity="other">%d mreža</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="5802057518058840450">
      <item quantity="one">%d prijava</item>
      <item quantity="few">%d prijave</item>
      <item quantity="other">%d prijava</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="5125849180309374451">
      <item quantity="one">%d mreža i prijava</item>
      <item quantity="few">%d mreže i prijave</item>
      <item quantity="other">%d mreža i prijava</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="1234150304285575798">"Napredna Wi-Fi podešavanja"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"MAC adresa uređaja"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Nasumična MAC adresa"</string>
    <string name="wifi_advanced_ip_address_title" msgid="4265355419782184514">"IP adresa"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detalji o mreži"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podmreže"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6 adrese"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Sačuvane mreže"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Pretplate"</string>
    <!-- no translation found for wifi_saved_access_points_tab (2075914709522121708) -->
    <skip />
    <string name="wifi_advanced_settings_label" msgid="5880605751602184383">"IP podešavanja"</string>
    <string name="wifi_advanced_not_available" msgid="8701003884367299092">"Napredna podešavanja Wi‑Fi mreže nisu dostupna za ovog korisnika"</string>
    <string name="wifi_ip_settings_menu_save" msgid="5190481040428567106">"Sačuvaj"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="1757817733064004598">"Otkaži"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Unesite važeću IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Unesite važeću adresu mrežnog prolaza."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Unesite važeću DNS adresu."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Unesite prefiks mreže dužine između 0 i 32 znaka."</string>
    <string name="wifi_dns1" msgid="6462967242512284778">"DNS 1"</string>
    <string name="wifi_dns2" msgid="8494337355389723965">"DNS 2"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Mrežni prolaz"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Dužina prefiksa mreže"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="4304362679971797283">"Informacije o uređaju"</string>
    <string name="wifi_p2p_persist_network" msgid="7942929491568227945">"Zapamti ovu vezu"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Pretraži uređaje"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Pretražuje se…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Preimenuj uređaj"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Ravnopravni uređaji"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Zapamćene grupe"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Povezivanje nije moguće."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Preimenovanje uređaja nije uspelo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Želite li da prekinete vezu?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Ako prekinete vezu, okončaćete vezu sa uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Ako prekinete vezu, okončaćete vezu sa uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g> i drugim uređajima (<xliff:g id="PEER_COUNT">%2$s</xliff:g>)."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Želite li da otkažete pozivnicu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Želite li da otkažete pozivnicu za povezivanje sa uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Želite li da zaboravite ovu grupu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wi-Fi hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Ni internet ni sadržaj se ne dele sa drugim uređajima"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5832429443898690152">"Internet veza ovog tableta se deli preko hotspota"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5451921191609178326">"Internet veza ovog telefona se deli preko hotspota"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="965051079784031636">"Aplikacija deli sadržaj. Da biste delili internet vezu, isključite, pa uključite hotspot"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Niste podesili lozinku"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Naziv hotspota"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="6178719924661022928">"<xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g> se uključuje..."</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="6935457127884928249">"Drugi uređaji mogu da se povežu sa hotspotom <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Lozinka hotspota"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Opseg pristupne tačke"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="6620216295510397461">"Koristite hotspot da biste napravili Wi‑Fi mrežu za druge uređaje. Hotspot pruža internet pomoću veze za mobilne podatke. Možda će važiti dodatne tarife za mobilne podatke."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="3813311942370920903">"Aplikacije mogu da prave hotspotove za deljenje sadržaja sa obližnjim uređajima."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Automatski isključi hotspot"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kada nijedan uređaj nije povezan"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Uključivanje hotspota…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Isključivanje hotspota..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivan"</string>
    <string name="wifi_tether_failed_subtext" msgid="437190628041885500">"Greška prenosnog Wi‑Fi hotspota"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7072559431286459122">"Podesi Wi-Fi hotspot"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="9027072969831022321">"Podešavanje Wi‑Fi hotspota"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="1445157424926935178">"AndroidAP WPA2 PSK hotspot"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Želite li da sačuvate ovu mrežu?"</string>
    <string name="wifi_add_app_single_network_summary" product="default" msgid="6881712878537666626">"<xliff:g id="APPNAME">%1$s</xliff:g> želi da sačuva mrežu na telefonu"</string>
    <string name="wifi_add_app_single_network_summary" product="tablet" msgid="8455616967601552440">"<xliff:g id="APPNAME">%1$s</xliff:g> želi da sačuva mrežu na telefonu"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Čuva se…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Sačuvano"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Čuvanje nije uspelo. Probajte ponovo."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Želite li da sačuvate mreže?"</string>
    <string name="wifi_add_app_networks_summary" product="default" msgid="2670215712788515167">"<xliff:g id="APPNAME">%1$s</xliff:g> želi da sačuva ove mreže na telefonu"</string>
    <string name="wifi_add_app_networks_summary" product="tablet" msgid="2088967184512169910">"<xliff:g id="APPNAME">%1$s</xliff:g> želi da sačuva ove mreže na tabletu"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Čuvaju se mreže (<xliff:g id="NUMBER">%d</xliff:g>)…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Mreže su sačuvane"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Pozivanje preko Wi-Fi-ja"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Produžite pozive pomoću Wi‑Fi-ja"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Uklj. pozivanje preko Wi‑Fi-ja da proširite pokrivenost"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Podešavanje pozivanja"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Podešavanje pozivanja"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Podešavanja rominga"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Podešavanja rominga"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobilni podaci"</item>
    <item msgid="3027927219952052398">"Samo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mobilni podaci"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Ako je Wi‑Fi nedostupan, koristite mobilnu mrežu"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Ako mobilna mreža nije dostupna, koristi Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Pozivanje preko Wi-Fi-ja. Ako se Wi‑Fi veza izgubi, poziv će se završiti."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kada je pozivanje preko Wi-Fi-ja uključeno, telefon može da preusmerava pozive preko Wi-Fi mreža ili mreže mobilnog operatera u zavisnosti od toga koje ste podešavanje izabrali i koji signal je jači. Pre nego što uključite ovu funkciju, informišite se kod mobilnog operatera o naknadama i drugim detaljima.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="3490633500025717573">"Adresa za hitne slučajeve"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Koristi se kao vaša lokacija kada uputite hitni poziv pomoću Wi-Fi-ja"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Saznajte više"</annotation>" o funkcijama Privatnog DNS-a"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Uključeno"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="129524064888622179">"Mobilni operater upravlja podešavanjem"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivirajte Pozivanje preko Wi-Fi-ja"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Uključite pozivanje preko Wi-Fi-ja"</string>
    <string name="wifi_calling_not_supported" msgid="3303917737849393175">"Pozivanje preko Wi-Fi-ja nije podržano za %1$s"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Prekinuta je veza sa: <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="carrier" msgid="1755020806290963951">"Mobilni operater"</string>
    <string name="display_settings_title" msgid="626835071804834218">"Prikaz"</string>
    <string name="sound_settings" msgid="5514582720435174014">"Zvuk"</string>
    <string name="all_volume_title" msgid="6196367642878437513">"Jačine zvuka"</string>
    <string name="musicfx_title" msgid="5458574743312283473">"Muzički efekti"</string>
    <string name="ring_volume_title" msgid="4869034595079914541">"Jačina zvuka za zvono i obaveštenja"</string>
    <string name="vibrate_in_silent_title" msgid="5076579100685867363">"Vibracija u nečujnom režimu"</string>
    <string name="notification_sound_title" msgid="8747567935870133157">"Podrazumevani zvuk obaveštenja"</string>
    <string name="incoming_call_volume_title" msgid="8445408274513654261">"Zvuk zvona"</string>
    <string name="notification_volume_title" msgid="328053763590888609">"Obaveštenje"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1798481722572489141">"Koristi jačinu zvuka dolaznog poziva za obaveštenja"</string>
    <string name="home_work_profile_not_supported" msgid="2605589489324241338">"Ne podržava profile za posao"</string>
    <string name="notification_sound_dialog_title" msgid="7431891669251806266">"Podrazumevani zvuk obaveštenja"</string>
    <string name="media_volume_title" msgid="5209147840160985178">"Mediji"</string>
    <string name="media_volume_summary" msgid="4671324482655564873">"Podešavanje jačine zvuka za muziku i video snimke"</string>
    <string name="alarm_volume_title" msgid="706302621191735343">"Alarm"</string>
    <string name="dock_settings_summary" msgid="8548721822219932359">"Audio podešavanja za prikačeno postolje"</string>
    <string name="dtmf_tone_enable_title" msgid="2241337296249130217">"Tonovi prilikom dodira numeričke tastature"</string>
    <string name="sound_effects_enable_title" msgid="328569690466233866">"Zvukovi pri dodirima"</string>
    <string name="lock_sounds_enable_title" msgid="804365014499259673">"Zvuk zaključavanja ekrana"</string>
    <string name="audio_record_proc_title" msgid="486071779724181619">"Umanjivanje šuma"</string>
    <string name="volume_media_description" msgid="2736061076584067204">"Muzika, video, igre i drugi mediji"</string>
    <string name="volume_ring_description" msgid="5423168446359881864">"Melodija zvona i obaveštenja"</string>
    <string name="volume_notification_description" msgid="3241009629930030492">"Obaveštenja"</string>
    <string name="volume_alarm_description" msgid="156563371961039376">"Alarmi"</string>
    <string name="volume_ring_mute" msgid="1445718401945149622">"Isključi zvuk melodije zvona i obaveštenja"</string>
    <string name="volume_media_mute" msgid="1881020121757820746">"Isključi muziku i druge medije"</string>
    <string name="volume_notification_mute" msgid="2612197659377126312">"Isključi zvuk obaveštenja"</string>
    <string name="volume_alarm_mute" msgid="3730895630530980760">"Isključi zvuk alarma"</string>
    <string name="dock_settings" msgid="4654404127402812514">"Pričvršćivanje"</string>
    <string name="dock_settings_title" msgid="1276956575555480214">"Podešavanja bazne stanice"</string>
    <string name="dock_audio_settings_title" msgid="8294821925086965934">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="4158593887711452737">"Podešavanja za priključeno stono postolje"</string>
    <string name="dock_audio_summary_car" msgid="292911654994476080">"Podešavanja za priključeno postolje za automobil"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="7758416095500202500">"Tablet nije na baznoj stanici"</string>
    <string name="dock_audio_summary_none" product="default" msgid="9056359991181743485">"Telefon nije pričvršćen"</string>
    <string name="dock_audio_summary_unknown" msgid="5486086330763810318">"Podešavanja za priključeno postolje"</string>
    <string name="dock_not_found_title" msgid="4721157149003423417">"Postolje nije pronađeno"</string>
    <string name="dock_not_found_text" product="tablet" msgid="9192097687086523411">"Treba da postavite tablet na baznu stanicu pre nego što podesite zvuk bazne stanice."</string>
    <string name="dock_not_found_text" product="default" msgid="2247163115146852069">"Potrebno je da postavite telefon na baznu stanicu pre nego što podesite zvuk bazne stanice."</string>
    <string name="dock_sounds_enable_title" msgid="2974614136344237932">"Zvuk umetanja bazne stanice"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="468592489565539336">"Reprodukuj zvuk prilikom postavljanja tableta na baznu stanicu ili uklanjanja sa nje"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8121670617316301768">"Puštanje zvuka kada se telefon stavlja na postolje ili uklanja sa njega"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="7833926726878567889">"Ne reprodukuj zvuk prilikom postavljanja tableta na baznu stanicu ili uklanjanja sa nje"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="5560601997128422001">"Ne puštaj zvuk prilikom umetanja telefona na postolje ili uklanjanja sa njega"</string>
    <string name="account_settings" msgid="255404935489127404">"Nalozi"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Nalozi profila za posao – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Nalozi ličnog profila"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Nalog za posao – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Lični nalog – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Pretraga"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ekran"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automatsko rotiranje ekrana"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Boje"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Prirodne"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Pojačane"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Zasićene"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Prilagodljivo"</string>
    <string name="color_mode_summary_natural" msgid="8298840714001791628">"Koristite samo tačne boje"</string>
    <string name="color_mode_summary_automatic" msgid="8157885594041700275">"Birajte između živopisnih i tačnih boja"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="6413384391658481700">"Promeni položaj automatski prilikom rotiranja tableta"</string>
    <string name="accelerometer_summary_on" product="default" msgid="7117139542131700779">"Automatska promena položaja prilikom rotacije telefona"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="3747370091309939684">"Promeni položaj automatski prilikom rotiranja tableta"</string>
    <string name="accelerometer_summary_off" product="default" msgid="4451125241783158763">"Automatska promena položaja prilikom rotacije telefona"</string>
    <string name="brightness" msgid="6216871641021779698">"Nivo osvetljenosti"</string>
    <string name="brightness_title" msgid="5457874893085305155">"Osvetljenost"</string>
    <string name="brightness_summary" msgid="6309641759293018049">"Prilagođavanje osvetljenosti ekrana"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Prilagodljiva osvetljenost"</string>
    <string name="auto_brightness_summary" msgid="1737148869232725883">"Osvetljenost ekrana se prilagođava okolini"</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Uključeno"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Isključeno"</string>
    <string name="auto_brightness_summary_very_low" msgid="2705445901659224330">"Željena osvetljenost je veoma niska"</string>
    <string name="auto_brightness_summary_low" msgid="1606100911112851291">"Željena osvetljenost je niska"</string>
    <string name="auto_brightness_summary_default" msgid="9038441148247815684">"Željena osvetljenost je podrazumevana"</string>
    <string name="auto_brightness_summary_high" msgid="2886260311484349010">"Željena osvetljenost je visoka"</string>
    <string name="auto_brightness_summary_very_high" msgid="8294814315426024005">"Željena osvetljenost je veoma visoka"</string>
    <string name="auto_brightness_off_title" msgid="5156056957376839677">"Isključi"</string>
    <string name="auto_brightness_very_low_title" msgid="618973599332847430">"Veoma niska"</string>
    <string name="auto_brightness_low_title" msgid="4243763334776382492">"Niska"</string>
    <string name="auto_brightness_default_title" msgid="1776584786251120907">"Podrazumevano"</string>
    <string name="auto_brightness_high_title" msgid="6472704542949390468">"Visoka"</string>
    <string name="auto_brightness_very_high_title" msgid="4935132626750630713">"Veoma visoka"</string>
    <string name="auto_brightness_subtitle" msgid="6839449395639517870">"Željeni nivo osvetljenosti"</string>
    <string name="auto_brightness_off_summary" msgid="4993150980274474226">"Nemoj da prilagođavaš prema dostupnom svetlu"</string>
    <string name="auto_brightness_very_high_summary" msgid="2784981315548144255">"Veća potrošnja baterije"</string>
    <string name="auto_brightness_disclaimer" msgid="1868395832774087351">"Optimizujte nivo osvetljenosti prema svetlu. Možete privremeno da podesite osvetljenost i kad je ova opcija uključena."</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Osvetljenost ekrana će se automatski prilagoditi okruženju i aktivnostima. Možete ručno da pomerate klizač da bi prilagodljivo podešavanje osvetljenosti naučilo šta vam odgovara."</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Balans bele ekrana"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Tečni prikaz"</string>
    <string name="peak_refresh_rate_summary" msgid="1527087897198455042">"Automatski podiže učestalost osvežavanja sa 60 na 90 Hz za određeni sadržaj. Povećava potrošnju baterije."</string>
    <string name="force_high_refresh_rate_toggle" msgid="5861514655252832828">"Nametni učestalost osvežavanja od 90 Hz"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Najveća učestalost osvežavanja za poboljšan odziv na dodir i kvalitet animacije. Povećava potrošnju baterije."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Pažnja ekrana"</string>
    <string name="adaptive_sleep_summary_on" msgid="313187971631243800">"Uključeno/ekran se neće isključiti ako gledate u njega"</string>
    <string name="adaptive_sleep_summary_off" msgid="5272156339202897523">"Isključeno"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Potreban je pristup kameri"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5107880175176848307">"Dodirnite da biste upravljali dozvolama za usluge personalizacije uređaja"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Sprečava isključivanje ekrana ako gledate u njega"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Pažnja ekrana koristi prednju kameru da bi utvrdila da li neko gleda u ekran. Radi na uređaju, a slike se nikada ne čuvaju niti šalju Google-u."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Uključite pažnju ekrana"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Sprečite isključivanje ekrana dok ga gledate"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Noćno svetlo"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Noćno svetlo daje ekranu žutonarandžastu nijansu. To vam omogućava da lakše pregledate sadržaj ekrana pri prigušenom svetlu i da lakše zaspite."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Zakažite"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Ništa"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Uključuje se u željeno vreme"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Uključuje se od sumraka do svitanja"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Vreme početka"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Vreme završetka"</string>
    <string name="night_display_status_title" msgid="9006282950657941820">"Status"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intenzitet"</string>
    <string name="night_display_summary_off" msgid="4676320734342206009">"Isključeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nikada se ne uključuje automatski"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Uključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Uključuje se automatski kada sunce zađe"</string>
    <string name="night_display_summary_on" msgid="8932395375143965229">"Uključeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nikada se ne isključuje automatski"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Isključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Isključuje se automatski kada sunce izađe"</string>
    <string name="night_display_activation_on_manual" msgid="7999294858026069365">"Uključi"</string>
    <string name="night_display_activation_off_manual" msgid="4842907786868153218">"Isključi"</string>
    <string name="night_display_activation_on_twilight" msgid="3440889451767582067">"Uključi do izlaska sunca"</string>
    <string name="night_display_activation_off_twilight" msgid="2853594955401726956">"Isključi do zalaska sunca"</string>
    <string name="night_display_activation_on_custom" msgid="4951143503599226846">"Uključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="79965738861100371">"Isključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Noćno svetlo trenutno nije uključeno"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Lokacija uređaja je potrebna za određivanje vremena izlaska i zalaska sunca."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Podešavanja lokacije"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Uključi"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Isključi"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Uključi do izlaska sunca"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Isključi do zalaska sunca"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tamni režim"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Zakažite"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Ništa"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Uključuje se od sumraka do svitanja"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Uključuje se u željeno vreme"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off" msgid="3897438633224959099">"Isključeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nikada se ne uključuje automatski"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Uključuje se automatski kada sunce zađe"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Uključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on" msgid="3886998135388176000">"Uključeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nikada se ne isključuje automatski"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Isključuje se automatski kada sunce izađe"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Isključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_on_custom" msgid="1889379402860316125">"Uključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_off_custom" msgid="2192932161592759607">"Isključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tamna tema koristi crnu pozadinu da bi baterija trajala duže na nekim ekranima. Rasporedi tamne teme čekaju da se uključe dok vam je ekran isključen."</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Gašenje ekrana"</string>
    <string name="screen_timeout_title" msgid="785134393520893049">"Ekran se isključuje"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Posle <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Pozadina"</string>
    <string name="style_and_wallpaper_settings_title" msgid="7580575814098427579">"Stilovi i pozadine"</string>
    <string name="wallpaper_settings_summary_default" msgid="7569803705735001813">"Podrazumevano"</string>
    <string name="wallpaper_settings_summary_custom" msgid="3174561317688848729">"Prilagođeno"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Promenite pozadinu"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalizujte ekran"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Izaberite pozadinu iz"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Prilagodite telefon"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Probajte drugačije stilove, pozadine i još toga"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Čuvar ekrana"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Tokom punjenja ili na baznoj stanici"</string>
    <string name="screensaver_settings_summary_either_short" msgid="2126139984738506920">"Bilo koje od ova dva"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Tokom punjenja"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Dok je na baznoj stanici"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nikada"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Isključeno"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1166343194760238835">"Da biste kontrolisali šta se dešava kada je telefon na baznoj stanici i/ili u stanju spavanja, uključite čuvar ekrana."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kada da počne"</string>
    <string name="screensaver_settings_current" msgid="390472865895976891">"Trenutni čuvar ekrana"</string>
    <string name="screensaver_settings_dream_start" msgid="6486360145976995856">"Započni odmah"</string>
    <string name="screensaver_settings_button" msgid="6159236558934930238">"Podešavanja"</string>
    <string name="automatic_brightness" msgid="4599827881929079513">"Automatski nivo osvetljenosti"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Podigni za aktivaciju"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambijentalni ekran"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kada da se prikazuje"</string>
    <string name="doze_title" msgid="1523090408230862316">"Probudi ekran zbog obaveštenja"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kada je ekran taman, uključuje se ambijentalni ekran za nova obaveštenja"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Uvek prikazuj vreme i podatke"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Potrošnja baterije je povećana"</string>
    <string name="title_font_size" msgid="570613010306330622">"Veličina fonta"</string>
    <string name="short_summary_font_size" msgid="184712645848458143">"Omogućava da tekst bude veći ili manji"</string>
    <string name="sim_lock_settings" msgid="4493069398250139205">"Zaključavanje SIM kartice"</string>
    <string name="sim_lock_settings_category" msgid="4280307997492851625">"Zaključavanje SIM kartice"</string>
    <string name="sim_lock_settings_summary_off" msgid="4570941250786847095">"Isključeno"</string>
    <string name="sim_lock_settings_summary_on" msgid="1562184566830887925">"Zaključano"</string>
    <string name="sim_lock_settings_title" msgid="1401619059761012696">"Zaključavanje SIM kartice"</string>
    <string name="sim_pin_toggle" msgid="98754920202404425">"Zaključaj SIM karticu"</string>
    <string name="sim_lock_on" product="tablet" msgid="5857965768682972363">"Zahtevaj PIN radi upotrebe tableta"</string>
    <string name="sim_lock_on" product="default" msgid="3303147192981388923">"Zahtevaj PIN radi upotrebe telefona"</string>
    <string name="sim_lock_off" product="tablet" msgid="7188936582548721225">"Zahtevaj PIN radi upotrebe tableta"</string>
    <string name="sim_lock_off" product="default" msgid="4634118006847137785">"Zahtevaj PIN radi upotrebe telefona"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Promeni SIM PIN"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM PIN"</string>
    <string name="sim_enable_sim_lock" msgid="8993991669975548653">"Zaključajte SIM karticu"</string>
    <string name="sim_disable_sim_lock" msgid="7656447857474746157">"Otključajte SIM karticu"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Stari SIM PIN"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Novi SIM PIN"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Ponovo unesite novi PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM PIN"</string>
    <string name="sim_bad_pin" msgid="5416328363761048221">"Netačan PIN"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN-ovi se ne podudaraju"</string>
    <string name="sim_change_failed" msgid="316723087029061740">"Nije moguće promeniti PIN.\nMoguće je da je PIN netačan."</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM PIN je uspešno promenjen"</string>
    <string name="sim_lock_failed" msgid="16360418201678317">"Nije moguće promeniti stanje zaključavanja SIM kartice.\nMoguće je da je PIN netačan."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Onemogućavanje PIN-a nije uspelo."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Omogućavanje PIN-a nije uspelo."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Potvrdi"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Otkaži"</string>
    <string name="sim_multi_sims_title" msgid="4875083890014013296">"Pronađeno je više SIM kartica"</string>
    <string name="sim_multi_sims_summary" msgid="1711012455679332238">"Izaberite željenu SIM karticu za mobilne podatke."</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Koristiti <xliff:g id="CARRIER">%1$s</xliff:g> za mob. podatke?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Koristite <xliff:g id="CARRIER2_0">%2$s</xliff:g> za mobilne podatke. Ako pređete na <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> se više neće koristiti za mobilne podatke."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Koristi <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="7182406911552216373">"Ažurirati željeni SIM?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jedina SIM kartica u uređaju. Želite li da koristite ovu SIM karticu za mobilne podatke, pozive i SMS poruke?"</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Netačan SIM PIN kôd. Sada morate da kontaktirate mobilnog operatera da biste otključali uređaj."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="4054088588731305475">
      <item quantity="one">Netačan SIM PIN kôd. Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaj.</item>
      <item quantity="few">Netačan SIM PIN kôd. Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
      <item quantity="other">Netačan SIM PIN kôd. Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
    </plurals>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Netačan PIN kôd za SIM. Imate još 1 pokušaj, a onda morate da kontaktirate mobilnog operatera da biste otključali uređaj."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Radnja sa SIM PIN kodom nije uspela!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Ažuriranja sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Android verzija"</string>
    <string name="security_patch" msgid="4071756145347865382">"Bezbednosno ažuriranje za Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_info" msgid="7035211991066637019">"Model i hardver"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Verzija hardvera"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID opreme"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Verzija osnovnog propusnog opsega"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Verzija jezgra"</string>
    <string name="build_number" msgid="9009733242117579826">"Broj verzije"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play ažuriranje sistema"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nije dostupno"</string>
    <string name="device_status_activity_title" msgid="1812666241137263882">"Status"</string>
    <string name="device_status" msgid="7988547478034984649">"Status"</string>
    <string name="device_status_summary" product="tablet" msgid="8826216824111648900">"Status baterije, mreže i ostale informacije"</string>
    <string name="device_status_summary" product="default" msgid="8132661857066128832">"Broj telefona, signal itd."</string>
    <string name="storage_settings" msgid="7472188817781592677">"Memorijski prostor"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Memorijski prostor i keš"</string>
    <string name="storage_usb_settings" msgid="7058142934214211583">"Memorijski prostor"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Podešavanja memorije"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3858049818577638926">"Isključivanje USB memorije, prikaz dostupne memorije"</string>
    <string name="storage_settings_summary" product="default" msgid="267557695753980969">"Oslobađanje SD kartice, prikaz dostupnog skladišta"</string>
    <string name="imei_multi_sim" msgid="71477088017585479">"IMEI (otvor za SIM: %1$d)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Da biste videli, odaberite sačuvanu mrežu"</string>
    <string name="status_number" product="tablet" msgid="3597945414666253183">"Broj mobilnog direktorijuma"</string>
    <string name="status_number" product="default" msgid="8407999629121682207">"Broj telefona"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="6582203988975619529">"MDN (otvor za SIM: %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="5724823197745786398">"Br. tel. (otvor za SIM: %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="4239876366511743428">"MDN na SIM kartici"</string>
    <string name="status_number_sim_status" product="default" msgid="2772745542921910086">"Broj telefona na SIM kartici"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL verzija"</string>
    <string name="meid_multi_sim" msgid="7645394486193991388">"MEID (otvor za SIM: %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="7644609329607744714">"Uključeno je Wi‑Fi i Bluetooth skeniranje"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="7215007787287418186">"Wi‑Fi skeniranje je uključeno, Bluetooth skeniranje je isključeno"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="1396882599556304165">"Bluetooth skeniranje je uključeno, Wi‑Fi skeniranje je isključeno"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="7670694707427030537">"Isključeno je Wi‑Fi i Bluetooth skeniranje"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Tip mreže za prenos podataka preko mobilnog operatera"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Tip glasovne mreže za prenos podataka preko mobilnog operatera"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informacije o mobilnom operateru"</string>
    <string name="status_data_state" msgid="525196229491743487">"Stanje mobilne mreže"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Stanje usluge"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Jačina signala"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Mreža"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Wi-Fi MAC adresa"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"MAC adresa uređaja za Wi‑Fi"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth adresa"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Serijski broj"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Vreme rada"</string>
    <string name="status_awake_time" msgid="2573925324168081586">"Vreme buđenja"</string>
    <string name="internal_memory" msgid="1869518160077033848">"Interno skladište"</string>
    <string name="sd_memory" product="nosdcard" msgid="5456718463397723781">"USB memorija"</string>
    <string name="sd_memory" product="default" msgid="3098344183202722455">"SD kartica"</string>
    <string name="memory_available" msgid="712528795743654737">"Dostupno"</string>
    <string name="memory_available_read_only" msgid="3201969221573511590">"Dostupno (samo za čitanje)"</string>
    <string name="memory_size" msgid="2710897518522931469">"Ukupan prostor"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Proračunavanje..."</string>
    <string name="memory_apps_usage" msgid="8818570780540532952">"Aplikacije i podaci aplikacija"</string>
    <string name="memory_media_usage" msgid="5161308657995646963">"Mediji"</string>
    <string name="memory_downloads_usage" msgid="8252462247720191179">"Preuzimanja"</string>
    <string name="memory_dcim_usage" msgid="3568913845973164352">"Slike, video snimci"</string>
    <string name="memory_music_usage" msgid="8100634000114206429">"Audio (muzika, zvukovi zvona, podkasti itd.)"</string>
    <string name="memory_media_misc_usage" msgid="7066851245178533269">"Druge datoteke"</string>
    <string name="memory_media_cache_usage" msgid="780808666853685824">"Keširani podaci"</string>
    <string name="sd_eject" product="nosdcard" msgid="6136102589751843304">"Isklj. deljene memorije"</string>
    <string name="sd_eject" product="default" msgid="8062832622096296251">"Oslobađanje SD kartice"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="6859940774161708871">"Isklj. interne USB memorije"</string>
    <string name="sd_eject_summary" product="default" msgid="5151243312587186226">"Isključite SD karticu da biste je bezbedno uklonili"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="9164545135649775664">"Umetnite USB za priključivanje"</string>
    <string name="sd_insert_summary" product="default" msgid="5949168259622002192">"Umetanje SD kartice za priključivanje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8305985249945415150">"Priključite USB memoriju"</string>
    <string name="sd_mount" product="default" msgid="5279813999455776169">"Priključivanje SD kartice"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="2190410240845521205"></string>
    <string name="sd_mount_summary" product="default" msgid="2190410240845521205"></string>
    <string name="sd_format" product="nosdcard" msgid="8657427883364711513">"Brisanje USB memorije"</string>
    <string name="sd_format" product="default" msgid="9085302892248732329">"Brisanje SD kartice"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6179784504937189658">"Briše sve podatke iz interne USB memorije, kao što su muzika i fotografije"</string>
    <string name="sd_format_summary" product="default" msgid="60583152211068164">"Briše sve podatke sa SD kartice, kao što su muzika i fotografije"</string>
    <string name="memory_clear_cache_title" msgid="2605096903803953619">"Želite li da obrišete keširane podatke?"</string>
    <string name="memory_clear_cache_message" msgid="4759561226480906588">"Biće obrisani keširani podaci za sve aplikacije."</string>
    <string name="mtp_ptp_mode_summary" msgid="7969656567437639239">"Funkcija MTP ili PTP je aktivna"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="7694112411895701320">"Želite da isključite USB memoriju?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="8251329019960361646">"Želite li da izvadite SD karticu?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="1212025106709645023">"Ako isključite USB memoriju, neke aplikacije koje koristite će se zaustaviti i možda neće biti dostupne dok ponovo ne priključite USB memoriju."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="3887768438615563697">"Ako izvadite SD karticu, neke aplikacije koje koristite će se zaustaviti i možda neće biti dostupne sve dok ponovo ne stavite SD karticu."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="7876201891724279436">"Nije moguće isključiti USB memoriju. Probajte ponovo kasnije."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="2185659901137961711">"Nije moguće isključiti SD karticu. Probajte ponovo kasnije."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="5932607205977999175">"USB memorija će biti isključena."</string>
    <string name="unmount_inform_text" product="default" msgid="716578785262713312">"SD kartica će biti isključena."</string>
    <string name="sd_ejecting_title" msgid="1641122369013595273">"Oslobađanje"</string>
    <string name="sd_ejecting_summary" msgid="861928572729341132">"Oslobađanje u toku"</string>
    <string name="storage_low_title" msgid="8002650511493419567">"Memorijski prostor je na izmaku."</string>
    <string name="storage_low_summary" msgid="7341022293583384506">"Neke sistemske funkcije, kao što je sinhronizacija, možda neće pravilno funkcionisati. Pokušajte da oslobodite prostor brisanjem ili otkačinjanjem stavki, kao što su aplikacije ili medijski sadržaj."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Preimenuj"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Priključi"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Izbaci"</string>
    <string name="storage_menu_format" msgid="5454870642788909443">"Formatiraj"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatiraj kao prenosnu"</string>
    <string name="storage_menu_format_private" msgid="3208326980027382079">"Formatiraj kao internu"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Prenesi podatke"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Zaboravi"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Podesi"</string>
    <string name="storage_menu_explore" msgid="3048031115521594488">"Istraži"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Oslobodite prostor"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Upravljaj memorijskim prostorom"</string>
    <string name="keywords_storage_menu_free" msgid="2275406357317597106">"obrisati, memorijski prostor"</string>
    <string name="storage_title_usb" msgid="1332488715547400452">"USB uređaj je povezan sa računarom"</string>
    <string name="usb_connection_category" msgid="2288543238378907242">"Poveži kao"</string>
    <string name="usb_mtp_title" msgid="9068009584556422314">"Medijski uređaj (MTP)"</string>
    <string name="usb_mtp_summary" msgid="6293240861011560842">"Omogućava vam da prenosite medijske datoteke u Windows-u, odnosno pomoću aplikacije Android File Transfer na Mač računarima (pogledajte www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="4496529268189091846">"Kamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="8382539472311655671">"Omogućava vam da prenosite fotografije pomoću softvera za kameru i da prenosite datoteke na računare koji ne podržavaju MTP"</string>
    <string name="usb_midi_title" msgid="1139558846427981761">"MIDI"</string>
    <string name="usb_midi_summary" msgid="1842457325845863840">"Omogućava aplikacijama sa omogućenim MIDI-jem da funkcionišu preko USB-a sa MIDI softverom na računaru."</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Ostali korisnici"</string>
    <string name="storage_internal_title" msgid="3265098802217660829">"Memorija uređaja"</string>
    <string name="storage_external_title" msgid="8984075540312137135">"Prenosna memorija"</string>
    <string name="storage_volume_summary" msgid="7087627975196777994">"Koristi se <xliff:g id="USED">%1$s</xliff:g> od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="5031288167242496837">"od ukupno <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="283558499413754323">"Ukupno se koristi <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je priključen"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Priključivanje uređaja <xliff:g id="NAME">%1$s</xliff:g> nije uspelo"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je bezbedno izbačen"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Bezbedno izbacivanje uređaja <xliff:g id="NAME">%1$s</xliff:g> nije uspelo"</string>
    <string name="storage_format_success" msgid="3028114521294256851">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je formatiran"</string>
    <string name="storage_format_failure" msgid="2042691589726261987">"Formatiranje nije uspelo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Preimenujte memoriju"</string>
    <string name="storage_dialog_unmounted" msgid="1187960789775910051">"Uređaj <xliff:g id="NAME_0">^1</xliff:g> je bezbedno izbačen, ali je još uvek dostupan. \n\nDa biste koristili uređaj <xliff:g id="NAME_1">^1</xliff:g>, prvo treba da ga priključite."</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Uređaj <xliff:g id="NAME_0">^1</xliff:g> je oštećen. \n\nDa biste koristili uređaj <xliff:g id="NAME_1">^1</xliff:g>, prvo treba da ga podesite."</string>
    <string name="storage_dialog_unsupported" msgid="7787241928013470089">"Ovaj uređaj ne podržava uređaj <xliff:g id="NAME_0">^1</xliff:g>. \n\nDa biste koristili uređaj <xliff:g id="NAME_1">^1</xliff:g> sa ovim uređajem, prvo treba da ga podesite."</string>
    <string name="storage_internal_format_details" msgid="8922023528848861812">"Posle formatiranja uređaj <xliff:g id="NAME_0">^1</xliff:g> možete da koristite sa drugim uređajima. \n\nSvi podaci na ovom uređaju <xliff:g id="NAME_1">^1</xliff:g> biće obrisani. Razmislite o tome da prvo napravite rezervnu kopiju podataka. \n\n"<b>"Napravite rezervnu kopiju slika i drugih medija"</b>" \nPremestite medijske datoteke u alternativnu memoriju na ovom uređaju ili ih prenesite na računar pomoću USB kabla. \n\n"<b>"Napravite rezervnu kopiju aplikacija"</b>" \nSve aplikacije sačuvane na ovom uređaju <xliff:g id="NAME_6">^1</xliff:g> biće deinstalirane i njihovi podaci biće izbrisani. Da biste zadržali ove aplikacije, premestite ih u alternativnu memoriju na ovom uređaju."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Kada izbacite ovaj uređaj <xliff:g id="NAME_0">^1</xliff:g>, aplikacije koje su na njemu sačuvane će prestati da funkcionišu i medijske datoteke koje su na njemu sačuvane neće biti dostupne dok ga ponovo ne umetnete."</b>" \n\nUređaj <xliff:g id="NAME_1">^1</xliff:g> se formatira da bi funkcionisao samo na ovom uređaju. Neće funkcionisati na drugim uređajima."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Da biste koristili aplikacije, slike ili podatke na ovom uređaju (<xliff:g id="NAME">^1</xliff:g>), umetnite ga ponovo. \n\nDruga mogućnost je da izaberete da zaboravite taj memorijski uređaj ako nije dostupan. \n\nAko odlučite da zaboravite, svi podaci na tom uređaju biće zauvek izgubljeni. \n\nAplikacije možete da kasnije ponovo instalirate, ali će podaci uskladišteni na uređaju biti izgubljeni."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Želite da zaboravite uređaj <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Sve aplikacije, slike i podaci sačuvani na uređaju <xliff:g id="NAME">^1</xliff:g> biće zauvek izbrisani."</string>
    <string name="storage_detail_apps" msgid="5055911985540355324">"Aplikacije"</string>
    <string name="storage_detail_images" msgid="6003883845718804371">"Slike"</string>
    <string name="storage_detail_videos" msgid="9079894412680404208">"Video snimci"</string>
    <string name="storage_detail_audio" msgid="234272983148223114">"Audio"</string>
    <string name="storage_detail_cached" msgid="4066364341463331199">"Keširani podaci"</string>
    <string name="storage_detail_other" msgid="3821329310612285961">"Drugo"</string>
    <string name="storage_detail_system" msgid="3797439069473271732">"Sistem"</string>
    <string name="storage_detail_explore" msgid="13782374784415466">"Istraži uređaj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="3359851869961609901">"Ostalo obuhvata deljene datoteke koje su sačuvale aplikacije, datoteke preuzete sa interneta ili Bluetooth-a, Android datoteke i tako dalje. \n\nDa biste videli vidljivi sadržaj na uređaju <xliff:g id="NAME">^1</xliff:g>, dodirnite Istražite."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sistem obuhvata datoteke koje se koriste za pokretanje verzije Android <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_detail_dialog_user" msgid="1691219071007313226">"<xliff:g id="USER_0">^1</xliff:g> možda ima sačuvane slike, muziku, aplikacije ili druge podatke, koji zauzimaju <xliff:g id="SIZE">^2</xliff:g> memorijskog prostora. \n\nDa biste pogledali detalje, pređite na <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="9036374223934708619">"Podesite uređaj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="6540132491909241713">"Koristi kao prenosivu memoriju"</string>
    <string name="storage_wizard_init_external_summary" msgid="5807552934494462984">"Za prenos slika i drugih medija sa jednog uređaja na drugi."</string>
    <string name="storage_wizard_init_internal_title" msgid="3256355049992147270">"Koristi kao internu memoriju"</string>
    <string name="storage_wizard_init_internal_summary" msgid="2283798331883929674">"Za čuvanje podataka samo na ovom uređaju, uključujući aplikacije i slike. Potrebno je formatiranje koje sprečava da memorijski uređaj funkcioniše sa drugim uređajima."</string>
    <string name="storage_wizard_format_confirm_title" msgid="4898014527956178762">"Formatir. kao internu memoriju"</string>
    <string name="storage_wizard_format_confirm_body" msgid="5514665245241830772">"Za ovo je potrebno da se uređaj <xliff:g id="NAME_0">^1</xliff:g> formatira da bi bio bezbedan. \n\nPosle formatiranja <xliff:g id="NAME_1">^1</xliff:g> će funkcionisati samo na ovom uređaju. \n\n"<b>"Formatiranjem se brišu svi podaci koji su trenutno sačuvani na uređaju <xliff:g id="NAME_2">^1</xliff:g>."</b>" Da ne biste izgubili podatke, razmislite o tome da napravite rezervnu kopiju podataka."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="649252654496577680">"Formatiranje prenosne memorije"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="6219883780307218266">"To zahteva da se <xliff:g id="NAME_0">^1</xliff:g> formatira. \n\n"<b>"Formatiranjem se brišu svi podaci koje trenutno sadrži <xliff:g id="NAME_1">^1</xliff:g>."</b>" Da ne biste izgubili podatke, razmislite o pravljenju rezervne kopije."</string>
    <string name="storage_wizard_format_confirm_next" msgid="4412063054982084056">"Obriši i formatiraj"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"<xliff:g id="NAME">^1</xliff:g> se formatira…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Ne uklanjajte uređaj <xliff:g id="NAME">^1</xliff:g> dok se formatira."</string>
    <string name="storage_wizard_migrate_title" msgid="3013711737005104623">"Prenesite podat. u novu memoriju"</string>
    <string name="storage_wizard_migrate_body" msgid="1630853797296198275">"Slike, datoteke i neke aplikacije možete da prenesete na ovaj novi uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nPrenos traje <xliff:g id="TIME">^2</xliff:g> čime se oslobađa <xliff:g id="SIZE">^3</xliff:g> interne memorije. Neke aplikacije neće funkcionisati tokom prenosa."</string>
    <string name="storage_wizard_migrate_now" msgid="175023718337037181">"Prenesi odmah"</string>
    <string name="storage_wizard_migrate_later" msgid="6573789572520980112">"Prenesi kasnije"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="255346780598924540">"Prenesite podatke odmah"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="5039938578355576124"><b>"Prenos traje oko <xliff:g id="TIME">^1</xliff:g>. <xliff:g id="NAME">^3</xliff:g> će dobiti <xliff:g id="SIZE">^2</xliff:g> slobodnog prostora."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="217478540562501692">"Prenesi"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="462238335086734131">"Podaci se prenose…"</string>
    <string name="storage_wizard_migrate_details" msgid="7474061662976940407">"Tokom prenosa: \n• Ne uklanjajte uređaj <xliff:g id="NAME">^1</xliff:g>. \n• Neke aplikacije neće pravilno funkcionisati. \n• Uređaj treba da bude napunjen."</string>
    <string name="storage_wizard_ready_title" msgid="3093468548660255543">"<xliff:g id="NAME">^1</xliff:g> je spreman/na za upotrebu"</string>
    <string name="storage_wizard_ready_external_body" msgid="45040717412844114">"Uređaj <xliff:g id="NAME">^1</xliff:g> je spreman da se koristi za slike i druge medije."</string>
    <string name="storage_wizard_ready_internal_body" msgid="7734817996475607447">"Novi uređaj <xliff:g id="NAME">^1</xliff:g> funkcioniše. \n\nDa biste preneli slike, datoteke i podatke aplikacija na ovaj uređaj, idite u Podešavanja &gt; Memorija."</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Prenesite aplikaciju <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Prenos aplikacije <xliff:g id="APP">^1</xliff:g> i njenih podataka na uređaj <xliff:g id="NAME_0">^2</xliff:g> trajaće nekoliko trenutaka. Aplikaciju nećete moći da koristite dok se prenos ne završi \n\nNe uklanjajte memorijski uređaj <xliff:g id="NAME_1">^2</xliff:g> tokom prenosa."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Da biste premestili podatke, treba da otključate korisnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"<xliff:g id="APP">^1</xliff:g> se prenosi…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Ne uklanjajte uređaj <xliff:g id="NAME">^1</xliff:g> tokom prenosa. \n\nAplikacija <xliff:g id="APP">^2</xliff:g> na ovom uređaju neće biti dostupna dok se prenos ne završi."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="3494022998599718937">"Otkaži prenos"</string>
    <string name="storage_wizard_slow_body" msgid="8293565076885232029">"Izgleda da <xliff:g id="NAME_0">^1</xliff:g> sporo funkcioniše. \n\nMožete da nastavite, ali aplikacije koje premestite na tu lokaciju će se možda prekidati i transferi podataka mogu dugo da traju. \n\nRazmislite o korišćenju bržeg uređaja <xliff:g id="NAME_1">^1</xliff:g> za bolji učinak."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Kako ćete koristiti uređaj <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="1884468440013151482">"Koristite kao dodatnu memoriju"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="2907833056467441047">"Za aplikacije, datoteke i medije samo na ovom tabletu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="3278694259614995649">"Memorijski prostor tableta"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="5941952998075252284">"Koristite kao dodatnu memoriju"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="3022584310096954875">"Za aplikacije, datoteke i medije samo na ovom telefonu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="5645732875040797464">"Memorijski prostor telefona"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Ili"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="8129096036551264207">"Koristite kao prenosivu memoriju"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="6436419488235871823">"Za prenos datoteka i medija sa jednog uređaja na drugi"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="781928899530539860">"Prenosiva memorija"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Podesiću kasnije"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Želite da formatirate uređaj <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"<xliff:g id="NAME_0">^1</xliff:g> zahteva formatiranje da biste mogli da čuvate aplikacije, datoteke i medije. \n\nFormatiranje briše podatke koje <xliff:g id="NAME_1">^2</xliff:g> sadrži. Da ne biste izgubili sadržaj, napravite njegovu rezervnu kopiju pomoću uređaja <xliff:g id="NAME_2">^3</xliff:g> ili nekog drugog."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatiraj: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Želite da pomerite sadržaj na: <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4541523202790415721">"Možete da premestite datoteke, medije i neke aplikacije na uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nOvo premeštanje će osloboditi <xliff:g id="SIZE">^2</xliff:g> memorijskog prostora tableta i trebalo bi da traje oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="809730501314645325">"Možete da premestite datoteke, medije i neke aplikacije na uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nOvo premeštanje će osloboditi <xliff:g id="SIZE">^2</xliff:g> memorijskog prostora telefona i trebalo bi da traje oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Tokom premeštanja:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ne uklanjajte uređaj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Neke aplikacije neće raditi"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="6111770421449869539">"Neka se tablet puni"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="8826915870192535008">"Neka se telefon puni"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Premesti sadržaj"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Premestiću sadržaj kasnije"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Sadržaj se premešta…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> sporo radi"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"I dalje možete da koristite uređaj <xliff:g id="NAME_0">^1</xliff:g>, ali će možda sporo raditi. \n\nAplikacije koje se nalaze na uređaju <xliff:g id="NAME_1">^2</xliff:g> možda neće ispravno raditi, a prenosi sadržaja će možda dugo trajati. \n\nProbajte da koristite brži uređaj <xliff:g id="NAME_2">^3</xliff:g> ili koristite uređaj <xliff:g id="NAME_3">^4</xliff:g> kao prenosivi memorijski prostor."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Počni ponovo"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Nastavi"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="3896836008684280905">"Možete da premestite sadržaj na <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="5710665992219332454">"Da biste premestili sadržaj na <xliff:g id="NAME">^1</xliff:g>, izaberite "<b>"Podešavanja &gt; Memorijski prostor"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1269878056598666852">"Sadržaj je premešten na <xliff:g id="NAME_0">^1</xliff:g>. \n\nDa biste upravljali uređajem <xliff:g id="NAME_1">^2</xliff:g>, izaberite "<b>"Podešavanja &gt; Memorijski prostor"</b>"."</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Status baterije"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nivo baterije"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Nazivi pristupnih tačaka"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Izmena pristupne tačke"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nije podešeno"</string>
    <string name="apn_name" msgid="6677695784108157953">"Naziv"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Naziv pristupne tačke"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proksi"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Korisničko ime"</string>
    <string name="apn_password" msgid="7435086635953953029">"Lozinka"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS proksi"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS port"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCK"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Tip potvrde identiteta"</string>
    <string name="apn_auth_type_none" msgid="6845031410929644238">"Ništa"</string>
    <string name="apn_auth_type_pap" msgid="9003475621032514182">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3587713509473187621">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="6852124741245095775">"PAP ili CHAP"</string>
    <string name="apn_type" msgid="1835573305077788773">"Tip naziva pristupne tačke"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol naziva pristupne tačke"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol naziva pristupne tačke u romingu"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Omogući/onemogući naziv pristupne tačke"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"Naziv pristupne tačke je omogućen"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"Naziv pristupne tačke je onemogućen"</string>
    <string name="bearer" msgid="3231443241639159358">"Nosilac"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Tip MVNO-a"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Vrednost MVNO-a"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Izbriši naziv pristupne tačke"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nov naziv pristupne tačke"</string>
    <string name="menu_save" msgid="6611465355127483100">"Sačuvaj"</string>
    <string name="menu_cancel" msgid="4526003389139913077">"Odbaci"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Polje Naziv ne sme da bude prazno."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Polje Naziv pristupne tačke ne sme da bude prazno."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Polje MCK mora da sadrži 3 cifre."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC polje mora da sadrži 2 ili 3 cifre."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Mobilni operater ne dozvoljava nazive pristupnih tačaka tipa %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Vraćanje podrazumevanih podešavanja naziva pristupne tačke."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Resetuj na podrazumevano"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Ponovno postavljanje podrazumevanih podešavanja naziva pristupne tačke je završeno."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Opcije za resetovanje"</string>
    <string name="reset_dashboard_summary" msgid="4390780188264852956">"Mreža, aplikacije ili uređaj mogu da se resetuju"</string>
    <string name="reset_dashboard_summary_onlyApps" msgid="3304252260039419584">"Aplikacije mogu da se resetuju"</string>
    <string name="reset_network_title" msgid="1395494440355807616">"Resetuj Wi-Fi, mobilnu mrežu i Bluetooth"</string>
    <string name="reset_network_desc" msgid="1112523764899788246">"Ovim resetujete sva podešavanja mreže, uključujući:\n\n"<li>"Wi‑Fi"</li>\n<li>"Mobilne podatke"</li>\n<li>"Bluetooth"</li></string>
    <string name="reset_esim_title" msgid="6152167073280852849">"Obriši preuzete SIM kartice"</string>
    <string name="reset_esim_desc" msgid="4256518544336245086">"Da biste preuzeli zamenske SIM kartice, kontaktirajte mobilnog operatera. Time se neće otkazati nijedan tarifni paket."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Resetuj podešavanja"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Želite li da resetujete sva podešavanja mreže? Ova radnja ne može da se opozove."</string>
    <string name="reset_network_final_desc_esim" msgid="8342882682282693844">"Želite li da resetujete podešavanja mreže i obrišete preuzete SIM kartice? Ova radnja ne može da se opozove."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Resetuj podešavanja"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Želite da resetujete?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Resetovanje mreže nije dostupno za ovog korisnika"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Podešavanja mreže su resetovana"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Brisanje SIM kartica nije uspelo"</string>
    <string name="reset_esim_error_msg" msgid="4441504470684307370">"Preuzete SIM kartice ne mogu da se obrišu zbog greške.\n\nRestartujte uređaj i probajte ponovo."</string>
    <string name="master_clear_title" msgid="5309249309235959383">"Izbriši sve podatke (vrati na fabrička podešavanja)"</string>
    <string name="master_clear_short_title" msgid="5331449583601739360">"Izbriši sve podatke (vrati na fabrička podešavanja)"</string>
    <string name="master_clear_desc" product="tablet" msgid="3114467865487750525">"Ovim brišete sve podatke iz "<b>"interne memorije"</b>" tableta, uključujući:\n\n"<li>"Google nalog"</li>\n<li>"podatke i podešavanja sistema i aplikacija"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="master_clear_desc" product="default" msgid="8447637796694856323">"Ovim brišete sve podatke iz "<b>"interne memorije"</b>" telefona, uključujući:\n\n"<li>"Google nalog"</li>\n<li>"Podaci i podešavanja sistema i aplikacija"</li>\n<li>"Preuzete aplikacije"</li></string>
    <string name="master_clear_accounts" product="default" msgid="142220980039357651">\n\n"Trenutno ste prijavljeni na sledeće naloge:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="7492338002408466023">\n\n"Na ovom uređaju su prisutni i drugi korisnici.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="4738661805356792736"><li>"Muzika"</li>\n<li>"Fotografije"</li>\n<li>"Drugi korisnički podaci"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6418163562288667727"><li>"eSIM-ovi"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="3112614935795369143">\n\n"Na taj način nećete otkazati mobilni tarifni paket."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7088655731755912201">\n\n"Da biste obrisali muziku, slike i druge korisničke podatke, treba da izbrišete "<b>"USB memoriju"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4145566517710675883">\n\n"Da biste obrisali muziku, slike i druge korisničke podatke, treba da izbrišete sadržaj "<b>"SD kartice"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="2182181846128639635">"Izbriši USB memoriju"</string>
    <string name="erase_external_storage" product="default" msgid="2610056855012660451">"Izbriši SD karticu"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="6358699244894944843">"Obriši sve podatke iz interne USB memorije, kao što su muzika i fotografije."</string>
    <string name="erase_external_storage_description" product="default" msgid="3367779850546310380">"Izbriši sve podatke sa SD kartice, kao što su muzika ili fotografije"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3554085992851027633">"Izbriši sve podatke"</string>
    <string name="master_clear_button_text" product="default" msgid="3554085992851027633">"Izbriši sve podatke"</string>
    <string name="master_clear_final_desc" msgid="5218005891800878932">"Izbrisaćete sve lične informacije i preuzete aplikacije. Ova radnja ne može da se opozove."</string>
    <string name="master_clear_final_desc_esim" msgid="3570139379312933326">"Sve lične informacije, uključujući preuzete aplikacije i SIM kartice, biće izbrisane. Ova radnja ne može da se opozove."</string>
    <string name="master_clear_final_button_text" msgid="1721164700940719292">"Izbriši sve"</string>
    <string name="master_clear_failed" msgid="6458678864313618526">"Nije obavljeno vraćanje na početne vrednosti zato što usluga brisanja sistema nije dostupna."</string>
    <string name="master_clear_confirm_title" msgid="632482173088680058">"Izbrisati sve podatke?"</string>
    <string name="master_clear_not_available" msgid="3419345724070828273">"Resetovanje na fabrička podešavanja nije dostupno za ovog korisnika"</string>
    <string name="master_clear_progress_title" msgid="480032747847804624">"Brisanje"</string>
    <string name="master_clear_progress_text" msgid="8891964820486632180">"Sačekajte..."</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Podešavanja poziva"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Podešavanje glasovne pošte, preusmeravanja poziva, stavljanja poziva na čekanje, ID-a pozivaoca"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB privezivanje"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Prenosni hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Bluetooth privezivanje"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Privezivanje"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot i privezivanje"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot je uključen, privezivanje"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot je uključen"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Privezivanje"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Nije moguće privezivanje niti korišćenje prenosivih hotspotova dok je Ušteda podataka uključena"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Samo hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Samo USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Samo Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Samo eternet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, eternet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, eternet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, eternet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, eternet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth, eternet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, eternet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth, eternet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internet se ne deli sa drugim uređajima"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Privezivanje"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Nemoj da koristiš Wi‑Fi hotspot"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Deli internet samo preko USB-a"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Deli internet samo preko Bluetooth-a"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Deli internet samo preko eterneta"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Deli internet samo preko USB-a i Bluetooth-a"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Deli internet samo preko USB-a i eterneta"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Deli internet samo preko Bluetooth-a i eterneta"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Deli internet samo preko USB-a, Bluetooth-a i eterneta"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB privezivanje"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3168636595109044213">"Deljenje internet veze telefona preko USB-a"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="1749659335004856576">"Deljenje internet veze tableta preko USB-a"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Bluetooth privezivanje"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="2023654677593885805">"Delite internet vezu tableta preko Bluetooth-a"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="4322810060538179348">"Deljenje internet veze telefona preko Bluetooth-a"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6941934844527406581">"Internet veza uređaja <xliff:g id="DEVICE_NAME">%1$d</xliff:g> se deli preko Bluetooth-a"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="5292358672240161566">"Privezivanje na više od <xliff:g id="MAXCONNECTION">%1$d</xliff:g> uređaja nije moguće."</string>
    <string name="bluetooth_untether_blank" msgid="5087548945727762308">"Internet veza sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> će biti prekinuta."</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Privezivanje eterneta"</string>
    <string name="ethernet_tethering_subtext" product="default" msgid="5998100693350351694">"Deljenje internet veze telefona preko eterneta"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Koristite hotspot i privezivanje da biste obezbedili internet drugim uređajima pomoću veze za mobilne podatke. Aplikacije mogu da prave hotspotove i za deljenje sadržaja sa uređajima u blizini."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Koristite hotspot i privezivanje da biste omogućili internet na drugim uređajima pomoću Wi‑Fi veze ili veze za prenos podataka preko mobilnog operatera. Aplikacije mogu i da prave hotspotove za deljenje sadržaja sa uređajima u blizini."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pomoć"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilna mreža"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Tarifni paket za mobilni uređaj"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikacija za SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Želite li da promenite aplikaciju za SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Želite li da koristite <xliff:g id="NEW_APP">%1$s</xliff:g> umesto <xliff:g id="CURRENT_APP">%2$s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Želite li da koristite <xliff:g id="NEW_APP">%s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="network_scorer_picker_title" msgid="2022922801936206195">"Dobavljač ocene mreže"</string>
    <string name="network_scorer_picker_none_preference" msgid="8894034333043177807">"Ništa"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Želite da promenite Wi‑Fi pomoćnik?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Želite li da koristite aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g> umesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Želite li da koristite aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Nepoznati SIM operater"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> nema poznat veb-sajt za dodelu"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Ubacite SIM karticu i restartujte"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Povežite se sa internetom"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavni zahtevi za lokaciju"</string>
    <string name="location_recent_location_requests_see_all" msgid="7918405176741692524">"Prikaži sve"</string>
    <string name="location_category_location_services" msgid="8163798686832434284">"Usluge lokacije"</string>
    <string name="location_title" msgid="5819154746934945021">"Moja lokacija"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za poslovni profil"</string>
    <string name="location_app_level_permissions" msgid="45436724900423656">"Pristup aplikacije lokaciji"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokacija je isključena"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="8286873148858526214">
      <item quantity="one"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> aplikacija od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> ima pristup lokaciji</item>
      <item quantity="few"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> aplikacije od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> imaju pristup lokaciji</item>
      <item quantity="other"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> aplikacija od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> ima pristup lokaciji</item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="7880996987927703141">"Nedavni pristup lokaciji"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Prikaži detalje"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Nijedna aplikacija nije nedavno tražila lokaciju"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Nijedna aplikacija nije nedavno pristupila lokaciji"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Velika potrošnja baterije"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Mala potrošnja baterije"</string>
    <string name="location_scanning_screen_title" msgid="2346125609614249968">"Wi‑Fi i Bluetooth skeniraju"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Wi‑Fi skeniranje"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Dozvolite aplikacijama i uslugama da traže Wi‑Fi mreže u bilo kom trenutku, čak i kada je Wi‑Fi isključen. Ovo može da se koristi, na primer, za poboljšanje funkcija i usluga zasnovanih na lokaciji."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth skeniranje"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Dozvolite aplikacijama i uslugama da traže uređaje u blizini u svakom trenutku, čak i kada je Bluetooth isključen. Ovo može da se koristi, na primer, za poboljšanje funkcija i usluga zasnovanih na lokaciji."</string>
    <string name="managed_profile_location_services" msgid="8172092734138341880">"Usluge lokacije za posao"</string>
    <string name="location_network_based" msgid="5247042890080021887">"Lokac. na osnovu Wi-Fi i mob. mreže"</string>
    <string name="location_neighborhood_level" msgid="3668890550358558267">"Neka apl. koriste Google-ovu uslugu lociranja za brže određivanje lokacije. Anonimni podaci o lokaciji prikupljaće se i slati Google-u."</string>
    <string name="location_neighborhood_level_wifi" msgid="6227393490651891977">"Lokacija se određuje pomoću Wi-Fi-ja"</string>
    <string name="location_gps" msgid="8783616672454701134">"GPS sateliti"</string>
    <string name="location_street_level" product="tablet" msgid="865953107414742784">"Neka aplikacije koriste GPS na tabletu kako bi tačno odredile vašu lokaciju"</string>
    <string name="location_street_level" product="default" msgid="3813836654645896185">"Neka aplikacije koriste GPS na telefonu kako bi tačno odredile vašu lokaciju"</string>
    <string name="assisted_gps" msgid="1714546606018821498">"Koristi pomoćni GPS"</string>
    <string name="assisted_gps_enabled" msgid="6220188450779319248">"Korišćenje servera za pomoć GPS mreži (opozovite izbor da biste smanjili korišćenje mreže)"</string>
    <string name="assisted_gps_disabled" msgid="1062496503892849">"Korišćenje servera za pomoć GPS mreži (opozovite izbor da biste poboljšali GPS učinak)"</string>
    <string name="use_location_title" msgid="1345594777162897654">"Lokacija i Google pretraga"</string>
    <string name="use_location_summary" msgid="377322574549729921">"Dozvoli da Google koristi lokaciju za poboljšanje rezultata pretrage i drugih usluga"</string>
    <string name="location_access_title" msgid="4052667453826272040">"Pristup mojoj lokaciji"</string>
    <string name="location_access_summary" msgid="8634100005481578143">"Neka aplikacije koje su tražile dozvolu koriste informacije o vašoj lokaciji"</string>
    <string name="location_sources_heading" msgid="6126965815860570524">"Izvori lokacije"</string>
    <string name="about_settings" product="tablet" msgid="2888705054709289693">"O tabletu"</string>
    <string name="about_settings" product="default" msgid="4038626127378127613">"O telefonu"</string>
    <string name="about_settings" product="device" msgid="9012888717090302815">"O uređaju"</string>
    <string name="about_settings" product="emulator" msgid="2516560858771320366">"O emuliranom uređaju"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Pregled pravnih informacija, statusa, verzije softvera"</string>
    <string name="legal_information" msgid="7509900979811934843">"Pravne informacije"</string>
    <string name="contributors_title" msgid="7965640251547037965">"Saradnici"</string>
    <string name="manual" msgid="3651593989906084868">"Uputstvo"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulatorne oznake"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Priručnik sa bezbednosnim i regulatornim podacima"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autorska prava"</string>
    <string name="license_title" msgid="8745742085916617540">"Licenca"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licence za ažuriranje sistema za Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Uslovi i odredbe"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licenca za sistemski WebView"</string>
    <string name="wallpaper_attributions" msgid="3080339190260272255">"Pozadine"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Dobavljači satelitskih slika:\n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Uputstvo"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Došlo je do problema pri učitavanju uputstva."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licence treće strane"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Došlo je do problema pri učitavanju licenci."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Učitava se…"</string>
    <string name="settings_safetylegal_title" msgid="1334501164265709288">"Bezbednosne informacije"</string>
    <string name="settings_safetylegal_activity_title" msgid="2218587051061093358">"Bezbednosne informacije"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="6571695168138207587">"Nemate vezu za prenos podataka. Da biste odmah pogledali ove informacije, idite na %s sa bilo kog računara koji je povezan na internet."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Učitava se…"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="7587198092214670356">"Podesite zaključavanje ekrana"</string>
    <string name="lockpassword_choose_your_password_message" msgid="4474728476383676731">"Podesite lozinku iz bezbednosnih razloga"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Podesite lozinku da biste koristili otisak"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Podesite šablon da biste koristili otisak"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Podesite PIN iz bezbednosnih razloga"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Podesite PIN da biste koristili otisak"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="5815780503576680412">"Podesite šablon iz bezbednosnih razloga"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Ponovo unesite lozinku"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Unesite lozinku poslovnog profila"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potvrdite šablon"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Unesite šablon poslovnog profila"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Ponovo unesite PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Unesite PIN za poslovni profil"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Lozinke se ne podudaraju"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN-ovi se ne podudaraju"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Ponovo nacrtajte šablon"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Izbor načina otključavanja"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Lozinka je postavljena"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN je postavljen"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Šablon je postavljen"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="5359649947642749079">"Otključavanje licem zahteva lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="9220480399170764760">"Otključavanje licem zahteva šablon"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="2285401208117502869">"Otključavanje licem zahteva PIN"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Zaboravili ste lozinku?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Zaboravili ste šablon?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Zaboravili ste PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Koristite šablon za uređaj da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Unesite PIN uređaja da biste nastavili"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Unesite lozinku uređaja da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Koristite šablon za poslovni profil da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Unesite PIN za poslovni profil da biste nastavili"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Unesite lozinku za poslovni profil da biste nastavili"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Radi veće bezbednosti koristite šablon za uređaj"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Radi veće bezbednosti unesite PIN za uređaj"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Radi veće bezbednosti unesite lozinku za uređaj"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Radi veće bezbednosti koristite šablon za posao"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Radi veće bezbednosti unesite poslovni PIN"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Radi veće bezbednosti unesite poslovnu lozinku"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6351784282865851482">"Telefon je resetovan na fabrička podešavanja. Da biste ga koristili, unesite prethodni šablon."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="2128795640346033349">"Telefon je resetovan na fabrička podešavanja. Da biste ga koristili, unesite prethodni PIN."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="4031863562975125016">"Telefon je resetovan na fabrička podešavanja. Da biste ga koristili, unesite prethodnu lozinku."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verifikujte šablon"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verifikujte PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verifikujte lozinku"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Pogrešan PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Pogrešna lozinka"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Pogrešan šablon"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Bezbednost uređaja"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Promeni šablon za otključavanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Promeni PIN za otključavanje"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Nacrtajte šablon za otključavanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Pritisnite „Meni“ da biste dobili pomoć."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Podignite prst kada završite"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Povežite najmanje <xliff:g id="NUMBER">%d</xliff:g> tačke. Probajte ponovo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Šablon je snimljen"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Ponovo nacrtajte šablon da biste potvrdili"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Novi šablon za otključavanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potvrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Ponovo nacrtaj"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Obriši"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Nastavi"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Šablon za otključavanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Zahtevaj šablon"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Potrebno je da nacrtate šablon za otključavanje ekrana"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Učini šablon vidljivim"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Učini šablon za profil vidljivim"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibriraj pri dodiru"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Dugme za napajanje odmah zaključava"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Osim kada ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> ostavlja otključanim"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Podešavanje šablona za otključavanje"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Promeni šablon za otključavanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kako nacrtati šablon za otključavanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Previše netačnih pokušaja. Probajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> sek."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikacija nije instalirana na telefonu."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Bezbednost poslovnog profila"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zaključavanje ekrana za poslovni profil"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Koristite jedno zaključavanje ekrana za poslovni profil i uređaj"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Želite li da koristite jedno zaključavanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Uređaj će koristiti zaključavanje ekrana za poslovni profil. Smernice za posao će se primenjivati na oba zaključavanja."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Zaključavanje ekrana za poslovni profil nije u skladu sa bezbednosnim zahtevima vaše organizacije. Možete da koristite isto zaključavanje ekrana za uređaj i poslovni profil, ali će se primenjivati sve smernice za zaključavanje ekrana za posao."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Isto kao zaključavanje ekrana uređaja"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Upravljaj aplikacijama"</string>
    <string name="manageapplications_settings_summary" msgid="848586372489062357">"Upravljanje instaliranim aplikacijama i njihovo uklanjanje"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informacije o aplikaciji"</string>
    <string name="applications_settings_summary" msgid="8206066893744768531">"Upravljanje aplikacijama, podešavanje prečica za brzo pokretanje"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Podešavanja aplikacija"</string>
    <string name="install_applications" msgid="3921609656584369901">"Nepoznati izvori"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Dozvoli sve izvore aplikacija"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nedavno otvarane aplikacije"</string>
    <plurals name="see_all_apps_title" formatted="false" msgid="6864581406735745400">
      <item quantity="one">Prikaži sve aplikacije (%1$d)</item>
      <item quantity="few">Prikaži sve aplikacije (%1$d)</item>
      <item quantity="other">Prikaži sve aplikacije (%1$d)</item>
    </plurals>
    <string name="forgot_password_title" msgid="3967873480875239885">"Obratite se IT administratoru"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"On može da vam pomogne da resetujete PIN, šablon ili lozinku"</string>
    <string name="install_all_warning" product="tablet" msgid="7010749217925069520">"Tablet i lični podaci su podložniji napadu nepoznatih aplikacija. Instaliranjem aplikacija iz ovog izvora prihvatate da ste odgovorni za oštećenja telefona ili gubitak podataka do kojih može da dođe zbog njihovog korišćenja."</string>
    <string name="install_all_warning" product="default" msgid="652516435709047343">"Telefon i lični podaci su podložniji napadu nepoznatih aplikacija. Instaliranjem aplikacija iz ovog izvora prihvatate da ste odgovorni za oštećenja telefona ili gubitak podataka do kojih može da dođe zbog njihovog korišćenja."</string>
    <string name="fdr_esim_failure_title" msgid="4776006228989385163">"Problem pri brisanju preuzetih SIM kartica"</string>
    <string name="fdr_esim_failure_text" msgid="8353414537422446964">"Restartujte uređaj i probajte ponovo. Ako nastavite sa resetovanjem na fabrička podešavanja, preuzete SIM kartice mogu da ostanu na uređaju."</string>
    <string name="fdr_esim_failure_reboot_btn" msgid="8629204185016602747">"Restartuj"</string>
    <string name="fdr_continue_title" msgid="5343622664826823937">"Resetovati na fabrička podešavanja?"</string>
    <string name="fdr_continue_text" msgid="860874694422515489">"Preuzete SIM kartice će ostati na uređaju."</string>
    <string name="fdr_continue_btn" msgid="1875421470422667092">"Resetuj na fabrička podešavanja"</string>
    <string name="install_all_warning" product="device" msgid="2348262609815354500">"Uređaj i lični podaci su podložniji napadu nepoznatih aplikacija. Ako instalirate aplikacije iz ovog izvora, prihvatate da ste odgovorni za eventualna oštećenja uređaja ili gubitak podataka do kojih može da dođe zbog njihovog korišćenja."</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Napredna podešavanja"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Omogući još opcija podešavanja"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Informacije o aplikaciji"</string>
    <string name="storage_label" msgid="2522307545547515733">"Memorijski prostor"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Podrazumevano otvaranje"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Podrazumevana podešavanja"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilnost ekrana"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Dozvole"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Keš"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Obriši keš"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Keš"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="8212425823423508096">
      <item quantity="one">%d stavka</item>
      <item quantity="few">%d stavke</item>
      <item quantity="other">%d stavki</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Obriši pristup"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontrole"</string>
    <string name="force_stop" msgid="2681771622136916280">"Prinudno zaustavi"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Ukupno"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Veličina aplikacije"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikacija USB memorije"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Podaci korisnika"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="1054860423004751290">"Podaci o USB memoriji"</string>
    <string name="external_data_size_label" product="default" msgid="3370825186202856353">"SD kartica"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Deinstaliraj"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Deinstaliraj za sve korisnike"</string>
    <string name="install_text" msgid="4558333621516996473">"Instaliraj"</string>
    <string name="disable_text" msgid="5146002260857428005">"Onemogući"</string>
    <string name="enable_text" msgid="8570798764647110430">"Omogući"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Obriši memorijski prostor"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Deinstaliraj ažuriranja"</string>
    <string name="auto_launch_enable_text" msgid="286244432074382294">"Izabrali ste podrazumevano pokretanje ove aplikacije za neke radnje."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Izabrali ste da dozvolite ovoj aplikaciji da pravi vidžete i pristupa njihovim podacima."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nisu postavljene podrazumevane vrednosti."</string>
    <string name="clear_activities" msgid="341345438786077236">"Obriši podrazumevano"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Ova aplikacija možda nije dizajnirana za vaš ekran. Ovde možete da kontrolišete kako će se prilagoditi vašem ekranu."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Pitaj pri pokretanju"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Promeni veličinu aplikacije"</string>
    <string name="unknown" msgid="8192160131923461175">"Nepoznato"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sortiraj prema imenu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sortiraj prema veličini"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Najnovije"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Najčešće"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Prikaži pokrenute usluge"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Prikaži keširane procese"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikacija za hitne slučajeve"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Resetuj podešavanja aplikacije"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Želite da resetujete podešavanja aplikacije?"</string>
    <string name="reset_app_preferences_desc" msgid="6509978724602405805">"Ovim ćete resetovati sva podešavanja za:\n\n"<li>"Onemogućene aplikacije"</li>\n<li>"Obaveštenja o onemogućenim aplikacijama"</li>\n<li>"Podrazumevane aplikacije za radnje"</li>\n<li>"Ograničenja za pozadinske podatke za aplikacije"</li>\n<li>"Sva ograničenja za dozvole"</li>\n\n"Nećete izgubiti nikakve podatke aplikacije."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Resetuj aplikacije"</string>
    <string name="manage_space_text" msgid="9013414693633572277">"Upravljaj prostorom"</string>
    <string name="filter" msgid="9039576690686251462">"Filtriraj"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Izbor opcija filtera"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Sve aplikacije"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Onemogućene aplikacije"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Preuzeto"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Pokretanje"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="5140211657134608469">"USB memorija"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1774499644768369891">"Na SD kartici"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nije instal. za ovog korisnika"</string>
    <string name="installed" msgid="2837449358488825884">"Instalirana"</string>
    <string name="no_applications" msgid="985069304755391640">"Nema aplikacija."</string>
    <string name="internal_storage" msgid="999496851424448809">"Interno skladište"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Ponovno izračunavanje veličine..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Želite li da izbrišete podatke o aplikaciji?"</string>
    <string name="clear_data_dlg_text" msgid="7870723948123690332">"Svi podaci ove aplikacije biće trajno izbrisani. To obuhvata sve datoteke, podešavanja, naloge, baze podataka itd."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Potvrdi"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Otkaži"</string>
    <string name="app_not_found_dlg_title" msgid="7122106240981109930"></string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikacija nije pronađena na listi instaliranih aplikacija."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Brisanje memorijskog prostora za aplikaciju nije uspelo."</string>
    <string name="join_two_items" msgid="7893073836681382429">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> i <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="5301233410730513655">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="4915310659841174866">"Izračunavanje..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nije moguće izračunati veličinu paketa."</string>
    <string name="version_text" msgid="7628938665256107608">"verzija <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Premesti"</string>
    <string name="move_app_to_internal" product="tablet" msgid="5799782476959541144">"Premesti na tablet"</string>
    <string name="move_app_to_internal" product="default" msgid="7395498801589544372">"Premesti u telefon"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="1145367822171576972">"Premesti u USB memoriju"</string>
    <string name="move_app_to_sdcard" product="default" msgid="7161667212614143767">"Premesti u SD karticu"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Drugi prenos je već u toku."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nema dovoljno prostora u memoriji."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikacija ne postoji."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Lokacija za instaliranje nije važeća."</string>
    <string name="system_package" msgid="7559476279008519360">"Nije moguće instalirati ažuriranja sistema na spoljašnjim medijima."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikacija za administratora uređaja ne može da se instalira na spoljnim medijima"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Želite li da prinudno zaustavite?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Ako prinudno zaustavite aplikaciju, možda će se ponašati neočekivano."</string>
    <string name="app_install_location_title" msgid="8932938164156303191">"Željena lokacija instalacije"</string>
    <string name="app_install_location_summary" msgid="4948270795544357021">"Menjanje željene lokacije za instalaciju novih aplikacija"</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Onemogući aplikaciju"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ako onemogućite ovu aplikaciju, Android i druge aplikacije možda više neće raditi ispravno. Imajte na umu da ne možete da izbrišete ovu aplikaciju jer je bila unapred instalirana na uređaju. Ako je onemogućite, isključićete ovu aplikaciju i sakrićete je na uređaju."</string>
    <string name="app_disable_notifications_dlg_title" msgid="6686569904059411780">"Želite li da isklj. obaveštenja?"</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Prodavnica"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detalji o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikacija je instalirana iz prodavnice <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Više informacija na <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Aktivno"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nikada nije korišćeno)"</string>
    <string name="no_default_apps" msgid="8966319676910104570">"Nema podrazumev. apl."</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Korišćenje memorije"</string>
    <string name="storageuse_settings_summary" msgid="5001621552305431831">"Pregled iskorišćene memorije po aplikacijama"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Ponovno pokretanje"</string>
    <string name="cached" msgid="5379485147573438201">"Keširani pozadinski proces"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nema pokrenutih usluga."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Započela je aplikacija."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> slobodno"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> isk."</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Korisnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Uklonjeni korisnik"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluge(a)"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesa i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesa i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memorija uređaja"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"RAM memorija koju koriste aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Slobodno"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"U upotrebi"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Keširano"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aktivna aplikacija"</string>
    <string name="no_services" msgid="3898812785511572899">"Nema aktivnih"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Usluge"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesi"</string>
    <string name="service_stop" msgid="5712522600201308795">"Zaustavi"</string>
    <string name="service_manage" msgid="3896322986828332075">"Podešavanja"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Ovu uslugu je pokrenula odgovarajuća aplikacija. Ako je zaustavite, aplikacija će možda otkazati."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Bezbedno zaustavljanje ove aplikacije nije moguće. Ako je zaustavite, možete da izgubite deo trenutnog rada."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Ovo je stari proces aplikacije koji još uvek traje u slučaju da opet bude potreban. Obično nema razloga za njegovo zaustavljanje."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutno se koristi. Dodirnite Podešavanja da biste ga kontrolisali."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Glavni proces koji se koristi."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Usluga <xliff:g id="COMP_NAME">%1$s</xliff:g> se trenutno koristi."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Dobavljač <xliff:g id="COMP_NAME">%1$s</xliff:g> se trenutno koristi."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Želite da zaustavite sistemsku uslugu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="2076922609580490122">"Ako zaustavite ovu uslugu, neke funkcije tableta će možda prestati ispravno da funkcionišu dok ne isključite i ponovo uključite tablet."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="2625863973434309085">"Ako zaustavite ovu uslugu, neke funkcije telefona će možda prestati ispravno da funkcionišu dok ne isključite i ponovo uključite telefon."</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Jezici, unos i pokreti"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="8670153838520237089"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="2738661322747920463"></string>
    <string name="language_input_gesture_summary_off" msgid="1604575860215661606"></string>
    <string name="language_settings" msgid="8700174277543875046">"Jezici i unos"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nemate dozvolu da menjate jezik uređaja."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Jezici i unos"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Alatke"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatura i metode unosa"</string>
    <string name="phone_language" msgid="5986939176239963826">"Jezici"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatska zamena"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Ispravljanje pogrešno unetih reči"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Automatsko pisanje velikih početnih slova"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Veliko slovo na početku rečenice"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatska interpunkcija"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Podešavanja fizičke tastature"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Pritisnite taster za razmak dvaput da biste umetnuli „.“"</string>
    <string name="show_password" msgid="7101900779571040117">"Prikazuj lozinke"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Prikazuje znakove nakratko dok kucate"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Ovaj kontrolor pravopisa možda može da prikuplja sav tekst koji kucate, uključujući lične podatke kao što su lozinke i brojevi kreditnih kartica. Potiče od aplikacije <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Želite li da koristite ovaj kontrolor pravopisa?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Podešavanja"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jezik"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastature"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Tastatura na ekranu"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Dostupna tastatura na ekranu"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Upravljajte tastaturama na ekranu"</string>
    <string name="keyboard_assistance_category" msgid="7320599809770932032">"Pomoć za tastaturu"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fizička tastatura"</string>
    <string name="show_ime" msgid="4334255501724746849">"Koristi tastaturu na ekranu"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Zadrži je na ekranu dok je fizička tastatura aktivna"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tasterske prečice"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="8649760728213630156">"Prikaz dostupnih prečica"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastature i alatke za poslovni profil"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Tastatura na ekranu za posao"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Podrazumevano"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Brzina pokazivača"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Kontroler za igre"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Preusmeri vibraciju"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Preusmeri vibraciju na kontroler za igre kada je povezan"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Izbor rasporeda tastature"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Podesi rasporede tastature"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Da biste prebacili, pritisnite Control-Spacebar"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Podrazumevano"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Rasporedi tastature"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Lični rečnik"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Lični rečnik za posao"</string>
    <string name="user_dict_settings_summary" msgid="262228126041933459"></string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Dodavanje u rečnik"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Više opcija"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Manje opcija"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Potvrdi"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Reč:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Prečica:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Unesite reč"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Opcionalna prečica"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Izmena reči"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Izmeni"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Nemate nijednu reč u korisničkom rečniku. Da biste dodali reč, dodirnite dugme Dodaj (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Za sve jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Još jezika..."</string>
    <string name="testing" msgid="6294172343766732037">"Testiranje"</string>
    <string name="testing_phone_info" product="tablet" msgid="1910768200608214456">"Informacije o tabletu"</string>
    <string name="testing_phone_info" product="default" msgid="1150527695827743906">"Informacije o telefonu"</string>
    <string name="input_methods_settings_title" msgid="7796027458321225550">"Unos teksta"</string>
    <string name="input_method" msgid="2982805181425436775">"Metod ulaza"</string>
    <string name="current_input_method" msgid="3471068842881330883">"Aktuelna tastatura"</string>
    <string name="input_method_selector" msgid="8463209725824763600">"Biranje metoda unosa"</string>
    <string name="input_method_selector_show_automatically_title" msgid="6483428482089875034">"Automatski"</string>
    <string name="input_method_selector_always_show_title" msgid="2479533500357556146">"Uvek prikaži"</string>
    <string name="input_method_selector_always_hide_title" msgid="807424180027384849">"Uvek sakrij"</string>
    <string name="configure_input_method" msgid="8831343065130376880">"Podešavanje metoda unosa"</string>
    <string name="input_method_settings" msgid="4177883733022569830">"Podešavanja"</string>
    <string name="input_method_settings_button" msgid="5145039044301426311">"Podešavanja"</string>
    <string name="input_methods_settings_label_format" msgid="5809693308957109022">"<xliff:g id="IME_NAME">%1$s</xliff:g> podešavanja"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="8940326108334307057">"Izbor metoda aktivnog unosa"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="3975358507879701606">"Podešavanja tastature na ekranu"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fizička tastatura"</string>
    <string name="builtin_keyboard_settings_summary" msgid="4332792334499933856">"Podešavanja fizičke tastature"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Izbor gadžeta"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Izbor vidžeta"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Želite li da napravite vidžet i dozvolite pristup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5694218981358874429">"Kada napravite vidžet, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> može da pristupa svim podacima koje prikazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Uvek dozvoli da <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> pravi vidžete i pristupa njihovim podacima"</string>
    <string name="usage_stats_label" msgid="6523644917803320085">"Statistika korišćenja"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Statistika korišćenja"</string>
    <string name="display_order_text" msgid="7120394778684605892">"Sortiraj prema:"</string>
    <string name="app_name_label" msgid="3809910527680143673">"Aplikacija"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Poslednji put korišćeno"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Vreme korišćenja"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Pristupačnost"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Podešavanja pristupačnosti"</string>
    <string name="accessibility_settings_summary" msgid="2195085206729325737">"Čitači ekrana, ekran, kontrole interakcije"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Podešavanja za vid"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Možete da prilagodite ovaj uređaj prema potrebama. Te funkcije pristupačnosti možete kasnije da promenite u Podešavanjima."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Promenite veličinu fonta"</string>
    <string name="screen_reader_category_title" msgid="6195867428854871553">"Čitači ekrana"</string>
    <string name="audio_and_captions_category_title" msgid="5049122378290004050">"Zvuk i tekst na ekranu"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Prikaz"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrole interakcije"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Preuzete aplikacije"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimentalno"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Oznake funkcija"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Čitač ekrana prvenstveno namenjen slepim i slabovidim osobama"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Dodirnite stavke na ekranu da biste ih čuli"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Podešavanja titla"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Uvećanje"</string>
    <string name="accessibility_magnification_mode_title" msgid="879250866604403721">"Oblast za uvećanje"</string>
    <string name="accessibility_magnification_enable_mode_title" msgid="4390488034396824276">"Omogućite uvećanje"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="4821458740248772054">"Odaberite oblasti za uvećanje koje želite da koristite kada uvećavate ekran"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Ceo ekran"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="5630032596384610913">"Deo ekrana"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="5139954486886669293">"Ceo ekran i deo ekrana"</string>
    <string name="accessibility_magnification_area_settings_full_screen" msgid="4189574224079433280">"Uvećajte ceo ekran"</string>
    <string name="accessibility_magnification_area_settings_window_screen" msgid="7431401975447232976">"Uvećajte deo ekrana"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Podešavanja uvećanja"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Uvećanje pomoću trostrukog dodira"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Uvećavajte pomoću prečice"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Uvećavajte pomoću prečice i trostrukog dodira"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"O usluzi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opcije"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Uvećajte prikaz na ekranu"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Dodirnite 3 puta da biste zumirali"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Dodirnite dugme da biste zumirali"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2023126829553044999">"Brzo uvećajte ekran da biste videli sadržaj jasnije.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Da biste uvećali:&lt;/b&gt;&lt;br/&gt; 1. Koristite prečicu da biste pokrenuli uvećanje&lt;br/&gt; 2. Dodirnite ekran&lt;br/&gt; 3. Prevlačite pomoću 2 prsta da biste se kretali po ekranu&lt;br/&gt; 4. Skupite 2 prsta da biste prilagodili zumiranje&lt;br/&gt; 5. Koristite prečicu da biste zaustavili uvećanje&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Da biste privremeno uvećali:&lt;/b&gt;&lt;br/&gt; 1. Koristite prečicu da biste pokrenuli uvećanje&lt;br/&gt; 2. Dodirnite i zadržite bilo koji deo ekrana&lt;br/&gt; 3. Prevlačite prst da biste se kretali po ekranu&lt;br/&gt; 4. Podignite prst da biste zaustavili uvećanje"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kada je uvećanje uključeno, možete da uvećate ekran.\n\n"<b>"Da biste zumirali"</b>", pokrenite uvećanje, pa dodirnite bilo koji deo ekrana.\n"<ul><li>"Prevlačite pomoću 2 ili više prstiju da biste pomerali prikaz"</li>\n<li>"Skupite 2 ili više prstiju da biste prilagodili zumiranje"</li></ul>\n\n<b>"Za privremeno zumiranje"</b>" pokrenite uvećanje, pa dodirnite i zadržite bilo koji deo ekrana.\n"<ul><li>"Prevlačite da biste se kretali po ekranu"</li>\n<li>"Podignite prst da biste umanjili prikaz"</li></ul>\n\n"Ne možete da uvećavate tastaturu ili traku za navigaciju."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. stranica od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Otvarajte pomoću dugmeta za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Zadržite tastere za jačinu zvuka da biste otvorili"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Triput dodirnite ekran da biste otvorili"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Otvarajte pomoću pokreta"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8485448068531147828">"Koristite novi pokret za pristupačnost"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Da biste koristili ovu funkciju, dodirnite dugme Pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> u dnu ekrana.\n\nDa biste prelazili sa jedne funkcije na drugu, dodirnite i zadržite dugme Pristupačnost."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Da biste koristili ovu funkciju, pritisnite i zadržite oba tastera za jačinu zvuka."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Da biste pokrenuli i zaustavili uvećanje, triput dodirnite bilo gde na ekranu."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Da biste koristili ovu funkciju, prevucite nagore od dna ekrana pomoću 2 prsta.\n\nDa biste prelazili sa jedne funkcije na drugu, prevucite nagore pomoću 2 prsta i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Da biste koristili ovu funkciju, prevucite nagore od dna ekrana pomoću 3 prsta.\n\nDa biste prelazili sa jedne funkcije na drugu, prevucite nagore pomoću 3 prsta i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Da biste koristili funkciju pristupačnosti, prevucite nagore od dna ekrana pomoću 2 prsta.\n\nDa biste prelazili sa jedne funkcije na drugu, prevucite nagore pomoću 2 prsta i zadržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Da biste koristili funkciju pristupačnosti, prevucite nagore od dna ekrana pomoću 3 prsta.\n\nDa biste prelazili sa jedne funkcije na drugu, prevucite nagore pomoću 3 prsta i zadržite."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Važi"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Prečica usluge <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Prevucite nagore pomoću 2 prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Prevucite nagore pomoću 3 prsta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Dodirnite dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Dodirnite dugme Pristupačnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> u dnu ekrana.\n\nDa biste prelazili sa jedne funkcije na drugu, dodirnite i zadržite dugme Pristupačnost."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Prevucite nagore od dna ekrana pomoću 2 prsta.\n\nDa biste prelazili sa jedne funkcije na drugu, prevucite nagore pomoću 2 prsta i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Prevucite nagore od dna ekrana pomoću 3 prsta.\n\nDa biste prelazili sa jedne funkcije na drugu, prevucite nagore pomoću 3 prsta i zadržite."</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Zadržite tastere za jačinu zvuka"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"zadržite tastere za jačinu zvuka"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Pritisnite i zadržite oba tastera za jačinu zvuka"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Dodirnite ekran triput"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"dodirnite ekran triput"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="3081710523998838305">"Brzo dodirnite ekran 3 puta. Ova prečica može da uspori uređaj."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Napredno"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Dugme za pristupačnost je podešeno na <xliff:g id="SERVICE">%1$s</xliff:g>. Da biste koristili uvećanje, dodirnite i zadržite dugme za pristupačnost, pa izaberite uvećanje."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Pokret za pristupačnost je podešen na funkciju <xliff:g id="SERVICE">%1$s</xliff:g>. Da biste koristili uvećanje, prevlačite nagore od dna ekrana pomoću dva prsta i zadržite. Zatim odaberite uvećanje."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Taster jačine zvuka kao prečica"</string>
    <string name="accessibility_shortcut_service_title" msgid="6842883700702723355">"Usluga prečice"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Podešavanja prečica"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Prečica sa zaključanog ekrana"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Dozvolite prečici funkcije da se uključi sa zaključanog ekrana. Zadržite oba tastera za jačinu zvuka par sekundi."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst visokog kontrasta"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatski ažuriraj uvelič. ekrana"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ažurira uveličavanje ekrana pri prelazu aplikacija"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Dugme uključi/isključi prekida poziv"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Veliki pokazivač miša"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Ukloni animacije"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="6692439394171709557">"Mono zvuk"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="6043673439531673935">"Kombinuj kanale pri puštanju audio sadržaja"</string>
    <string name="accessibility_toggle_master_balance_title" msgid="895584329613310279">"Balans zvuka"</string>
    <string name="accessibility_toggle_master_balance_left_label" msgid="147010366022601825">"Levo"</string>
    <string name="accessibility_toggle_master_balance_right_label" msgid="5028519887058073990">"Desno"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Podrazumevano"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekundi"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekundi"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minut"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minuta"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Period za reagovanje (vremensko ograničenje za pristupačnost)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Vreme za reagovanje"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="5283566580551714506">"Odaberite koliko dugo će se prikazivati poruke koje traže da reagujete, ali su vidljive samo privremeno.\n\nOvo podešavanje ne podržavaju sve aplikacije."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Odlaganje dodira i zadržavanja"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inverzija boja"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Koristi inverziju boja"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="6955835010409034745">"Inverzija boja pretvara svetle ekrane u tamne.&lt;br/&gt;&lt;br/&gt; Napomena: &lt;ol&gt; &lt;li&gt; Inverzija boja takođe menja tamne ekrane u svetle.&lt;/li&gt; &lt;li&gt; Boje se menjaju u medijima i na slikama.&lt;/li&gt; &lt;li&gt; Tamna tema može da se koristi za prikazivanje tamne pozadine. Tamna tema funkcioniše sa podržanim aplikacijama. Inverzija boja funkcioniše u svim aplikacijama.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatski klik (vreme zadržavanja)"</string>
    <string name="accessibility_autoclick_description" msgid="6827042379062255307">"Automatski klik radi sa povezanim mišem. Možete da podesite kursor da automatski klikne kada prestane da se kreće u određenom periodu."</string>
    <string name="accessibility_autoclick_default_title" msgid="752429113115293087">"Isključeno"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kratko"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekunde"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Srednje"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundi"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Dugo"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunda"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Prilagođeno"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kraće"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Duže"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Trajanje automatskog klika"</string>
    <string name="accessibility_vibration_settings_title" msgid="5198184603753129450">"Vibracije i jačina dodira"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibriranje obaveštenja"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibriranje zvona"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Dodirne povratne informacije"</string>
    <string name="accessibility_service_master_switch_title" msgid="3001666897585097640">"Koristite aplikaciju <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_master_open_title" msgid="7437956750557583681">"Otvorite aplikaciju <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="3580563017377754890">"Koristi korekciju boja"</string>
    <string name="accessibility_caption_master_switch_title" msgid="3821125170899547375">"Prikaži titl"</string>
    <string name="accessibility_caption_master_switch_summary" msgid="4908774362453838764">"Samo za podržane aplikacije"</string>
    <string name="captioning_caption_appearance_title" msgid="4501313548541670063">"Veličina i stil titla"</string>
    <string name="captioning_caption_appearance_summary" msgid="7340741178479381312">"Veličina teksta: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Još opcija"</string>
    <string name="accessibility_caption_preference_summary" msgid="1191356970836416954">"Neke aplikacije ne podržavaju ova podešavanja titla"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"dugme Pristupačnost"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Prevucite nagore od donjeg dela ekrana pomoću 2 prsta"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Zadržite tastere za jačinu zvuka"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Dodirnite ekran triput"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Nastavi"</string>
    <string name="accessibility_hearingaid_title" msgid="427173678199203191">"Slušni aparati"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"Nije povezan nijedan slušni aparat"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodajte slušne aparate"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="8913409742121315657">"Da biste uparili slušne aparate, pronađite i dodirnite uređaj na sledećem ekranu. Proverite da li su slušni aparati u režimu uparivanja."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"Aktivan: <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="776000580683647556">
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> sačuvani slušni aparat</item>
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> sačuvana slušna aparata</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> sačuvanih slušnih aparata</item>
    </plurals>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Prečica je uključena"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Isključeno"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Uključeno"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Isključeno"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Ne radi. Dodirnite da biste pročitali više informacija."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Ova usluga nije ispravna."</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Prikaži u Brzim podešavanjima"</string>
    <string name="daltonizer_type" msgid="1715154680803795947">"Režim ispravljanja"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="3811397143576433035">"Deuteranomalija"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6787594316700223938">"Protanomalija"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="1869867447813349033">"Tritanomalija"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="791173297742998942">"Crveno-zeleno"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="482834207025141433">"Crveno-zeleno"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2837137091067433059">"Plavo-žuto"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5354221071353645263">
      <item quantity="one">Kratko (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunda)</item>
      <item quantity="few">Kratko (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde)</item>
      <item quantity="other">Kratko (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundi)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_medium_delay" formatted="false" msgid="1550891909800510628">
      <item quantity="one">Srednje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunda)</item>
      <item quantity="few">Srednje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde)</item>
      <item quantity="other">Srednje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundi)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="2230755548820485984">
      <item quantity="one">Dugo (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunda)</item>
      <item quantity="few">Dugo (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde)</item>
      <item quantity="other">Dugo (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundi)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_delay_unit_second" formatted="false" msgid="4537791441118261556">
      <item quantity="one"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekunda</item>
      <item quantity="few"><xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekunde</item>
      <item quantity="other"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekundi</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="27904038683405084">"Zvono <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, obaveštenje <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>, dodir <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="7776105450117095736">"Zvono i obaveštenja su isključena"</string>
    <string name="accessibility_vibration_summary_low" msgid="6482721005400340317">"Zvono i obaveštenja su podešena na slabo"</string>
    <string name="accessibility_vibration_summary_medium" msgid="2348889320548746469">"Zvono i obaveštenja su podešena na srednje"</string>
    <string name="accessibility_vibration_summary_high" msgid="1764693979030913712">"Zvono i obaveštenja su podešena na jako"</string>
    <string name="accessibility_vibration_intensity_off" msgid="972159695404061944">"Isključeno"</string>
    <string name="accessibility_vibration_intensity_low" msgid="6311161118835287335">"Slabo"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="1734058611879392797">"Srednje"</string>
    <string name="accessibility_vibration_intensity_high" msgid="5982896399775212514">"Jako"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Podešavanja"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Uključeno"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Isključeno"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Pregled"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardne opcije"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Jezik"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Veličina teksta"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Stil titla"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Prilagođene opcije"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Boja pozadine"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Neprozirnost pozadine"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Boja prozora titla"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Prozirnost prozora titla"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Boja teksta"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Neprozirnost teksta"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Boja ivice"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Tip ivice"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Porodica fontova"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Titl će izgledati ovako"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Podrazumevano"</string>
    <string name="color_title" msgid="2511586788643787427">"Boja"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Podrazumevana"</string>
    <string name="color_none" msgid="3703632796520710651">"Ništa"</string>
    <string name="color_white" msgid="1896703263492828323">"Bela"</string>
    <string name="color_gray" msgid="8554077329905747877">"Siva"</string>
    <string name="color_black" msgid="9006830401670410387">"Crna"</string>
    <string name="color_red" msgid="5210756997426500693">"Crvena"</string>
    <string name="color_green" msgid="4400462091250882271">"Zelena"</string>
    <string name="color_blue" msgid="4997784644979140261">"Plava"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cijan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Žuta"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Želite li da dozvolite da <xliff:g id="SERVICE">%1$s</xliff:g> ima potpunu kontrolu nad uređajem?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> treba:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Pošto aplikacija skriva zahtev za dozvolu, Podešavanja ne mogu da verifikuju odgovor."</string>
    <string name="enable_service_encryption_warning" msgid="931082737770453755">"Ako uključite <xliff:g id="SERVICE">%1$s</xliff:g>, uređaj neće koristiti zaključavanje ekrana da bi poboljšao šifrovanje podataka."</string>
    <string name="secure_lock_encryption_warning" msgid="669152607190123579">"Pošto ste uključili uslugu pristupačnosti, uređaj neće koristiti zaključavanje ekrana da bi poboljšao šifrovanje podataka."</string>
    <string name="enable_service_pattern_reason" msgid="6832846117817938536">"Pošto uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifrovanje podataka, treba da potvrdite šablon."</string>
    <string name="enable_service_pin_reason" msgid="6040417014360237703">"Pošto uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifrovanje podataka, treba da potvrdite PIN."</string>
    <string name="enable_service_password_reason" msgid="6962544350351734238">"Pošto uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifrovanje podataka, treba da potvrdite lozinku."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> traži potpunu kontrolu nad ovim uređajem. Usluga može da čita sadržaj sa ekrana i da obavlja razne zadatke za korisnike usluga pristupačnosti. Ovaj nivo kontrole nije odgovarajući za većinu aplikacija."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Potpuna kontrola je primerena za aplikacije koje vam pomažu kod usluga pristupačnosti, ali ne i za većinu aplikacija."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Pregledaj i kontroliši ekran"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Može da čita sav sadržaj na ekranu i prikazuje ga u drugim aplikacijama."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Pregledaj i obavljaj radnje"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Može da prati interakcije sa aplikacijom ili senzorom hardvera i koristi aplikacije umesto vas."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Dozvoli"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Odbij"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Zaustavi"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Otkaži"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Želite li da zaustavite <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Ako dodirnete <xliff:g id="STOP">%1$s</xliff:g>, zaustavićete uslugu <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nijedna usluga nije instalirana"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nijedna usluga nije izabrana"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nije naveden opis."</string>
    <string name="settings_button" msgid="2195468788019730377">"Podešavanja"</string>
    <string name="print_settings" msgid="8519810615863882491">"Štampanje"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Isključeno"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="1034273609054146099">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> usluga štampanja je uključena</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> usluge štampanja su uključene</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> usluga štampanja je uključeno</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="3933688846338306536">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> zadatak za štampanje</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> zadatka za štampanje</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> zadataka za štampanje</item>
    </plurals>
    <string name="print_settings_title" msgid="7680498284751129935">"Usluge štampanja"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nijedna usluga nije instalirana"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nije pronađen nijedan štampač"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Podešavanja"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Dodaj štampače"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Uključeno"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Isključeno"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Dodaj uslugu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Dodaj štampač"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Pretraži"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Pretraga štampača"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Usluga je onemogućena"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Zadaci za štampanje"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Zadatak za štampanje"</string>
    <string name="print_restart" msgid="4424096106141083945">"Restartuj"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Otkaži"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> se konfiguriše"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Štampa se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Otkazuje se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Greška štampača <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Štampač je blokirao <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Okvir za pretragu se prikazuje"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Okvir za pretragu je sakriven"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Još informacija o ovom štampaču"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterija"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Šta koristi bateriju"</string>
    <string name="power_usage_not_available" msgid="3425302437465106036">"Nema podataka o upotrebi baterije."</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Još <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"Puni se još <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="background_activity_title" msgid="8214332017349791380">"Ograničenje aplikacija u pozadini"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Dozvolite aplikaciji da se pokreće u pozadini"</string>
    <string name="background_activity_summary_disabled" msgid="32459916080651444">"Aplikacije kojima nije dozvoljeno pokretanje u pozadini"</string>
    <string name="background_activity_summary_whitelisted" msgid="6808917852577742965">"Aplikacije u pozadini ne možete da ograničite"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Želite li da ograničite aktivnosti u pozadini?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ako ograničite aktivnosti aplikacije u pozadini, možda će se ponašati neočekivano."</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Apl. nije podešena za optimizaciju baterije, pa ne možete da je ograničite. \n\nZa ogr. apl. uključite optimizaciju baterije."</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Korišćenje ekrana od potpunog punjenja"</string>
    <string name="power_usage_list_summary" msgid="3237540201918492925">"Korišćenje baterije od potpunog punjenja"</string>
    <string name="screen_usage_summary" msgid="1393184943010909471">"Količina vremena tokom kojeg je ekran bio uključen od potpunog punjenja"</string>
    <string name="device_usage_list_summary" msgid="242243537371697285">"Korišćenje uređaja od potpunog punjenja"</string>
    <string name="battery_since_unplugged" msgid="6991509383429936921">"Korišćenje baterije nakon isključivanja"</string>
    <string name="battery_since_reset" msgid="2930376112877476562">"Korišćenje baterije nakon ponovnog postavljanja"</string>
    <string name="battery_stats_on_battery" msgid="1553011980384645514">"<xliff:g id="TIME">%1$s</xliff:g> na bateriji"</string>
    <string name="battery_stats_duration" msgid="6918768703070999743">"<xliff:g id="TIME">%1$s</xliff:g> od isključivanja"</string>
    <string name="battery_stats_charging_label" msgid="6204814386861342145">"Puni se"</string>
    <string name="battery_stats_screen_on_label" msgid="8989312180491200138">"Uključen ekran"</string>
    <string name="battery_stats_gps_on_label" msgid="5626424078405382686">"GPS je uključen"</string>
    <string name="battery_stats_camera_on_label" msgid="555635201416769359">"Kamera je uključena"</string>
    <string name="battery_stats_flashlight_on_label" msgid="1621027969559427783">"Lampa je uključena"</string>
    <string name="battery_stats_wifi_running_label" msgid="6461551370010379049">"Wi‑Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="8115041205778441548">"Budno stanje"</string>
    <string name="battery_stats_phone_signal_label" msgid="679649411998679555">"Signal mobilne mreže"</string>
    <!-- no translation found for battery_stats_last_duration (3088100394725340600) -->
    <skip />
    <string name="awake" msgid="5405871714019268978">"Vreme buđenja uređaja"</string>
    <string name="wifi_on_time" msgid="3880778525760926066">"Vreme od uključivanja Wi-Fi mreže"</string>
    <string name="bluetooth_on_time" msgid="8424625554628450028">"Vreme od uključivanja Wi-Fi mreže"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Potrošnja baterije"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalji istorije"</string>
    <string name="battery_details_title" msgid="4531369291819754178">"Potrošnja baterije"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Korišćenje detalja"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Prilagođavanje korišćenja napajanja"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Sadržani paketi"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikacije rade uobičajeno"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="6077959765904507849">"Telefon troši tipičnu količinu baterije u pozadini"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="5063158368808711973">"Tablet troši tipičnu količinu baterije u pozadini"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="4242899844618910548">"Uređaj troši tipičnu količinu baterije u pozadini"</string>
    <string name="battery_tip_low_battery_title" msgid="7789690720316830767">"Kapacitet baterije je nizak"</string>
    <string name="battery_tip_low_battery_summary" msgid="357649681960300945">"Baterija će se uskoro isprazniti"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2903272443772298636">"Produžite trajanje baterije telefona"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6813017377960004819">"Produžite trajanje baterije tableta"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4805599360437606335">"Produžite trajanje baterije uređaja"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Uključite menadžer baterije"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Uključite uštedu baterije"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Baterija može da se isprazni ranije nego obično"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4413270905575486715">"Ušteda baterije je uključena"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Neke funkcije mogu da budu ograničene"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="2375953293196088319">"Telefon ste koristili duže nego obično"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="8515903411746145740">"Tablet ste koristili duže nego obično"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="6577086402173910457">"Uređaj ste koristili duže nego obično"</string>
    <string name="battery_tip_high_usage_summary" msgid="5356399389711499862">"Baterija može da se isprazni ranije nego obično"</string>
    <string name="battery_tip_dialog_message" product="default" msgid="4681734836472195966">"Uređaj ste koristili duže nego obično. Baterija može da se isprazni ranije od očekivanog.\n\nAplikacije sa najvećom potrošnjom baterije:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="3934298305232120382">"Tablet ste koristili duže nego obično. Baterija može da se isprazni ranije od očekivanog.\n\nAplikacije sa najvećom potrošnjom baterije:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="2620789680336796054">"Uređaj ste koristili duže nego obično. Baterija može da se isprazni ranije od očekivanog.\n\nAplikacije sa najvećom potrošnjom baterije:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Uključuje aktivnosti u pozadini sa velikom potrošnjom"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="3108195491484891588">
      <item quantity="one">Ograničite %1$d aplikaciju</item>
      <item quantity="few">Ograničite %1$d aplikacije</item>
      <item quantity="other">Ograničite %1$d aplikacija</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="5862649927574803958">
      <item quantity="one">%2$d aplikacija je nedavno ograničena</item>
      <item quantity="few">%2$d aplikacije su nedavno ograničene</item>
      <item quantity="other">%2$d aplikacija je nedavno ograničeno</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="3328499737453686910">
      <item quantity="one">%2$d aplikacija puno troši bateriju u pozadini</item>
      <item quantity="few">%2$d aplikacije puno troše bateriju u pozadini</item>
      <item quantity="other">%2$d aplikacija puno troši bateriju u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="3036853535034350991">
      <item quantity="one">Ove aplikacije ne mogu da rade u pozadini</item>
      <item quantity="few">Ove aplikacije ne mogu da rade u pozadini</item>
      <item quantity="other">Ove aplikacije ne mogu da rade u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="7897944678619251740">
      <item quantity="one">Želite li da ograničite %1$d aplikaciju?</item>
      <item quantity="few">Želite li da ograničite %1$d aplikacije?</item>
      <item quantity="other">Želite li da ograničite %1$d aplikacija?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Da biste uštedeli bateriju, onemogućite da <xliff:g id="APP">%1$s</xliff:g> troši bateriju u pozadini. Ta aplikacija možda neće raditi kako treba i obaveštenja mogu da kasne."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Da biste uštedeli bateriju, onemogućite da ove aplikacije troše bateriju u pozadini. Ograničene aplikacije možda neće raditi kako treba i obaveštenja mogu da kasne.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Da biste uštedeli bateriju, onemogućite da ove aplikacije troše bateriju u pozadini. Ograničene aplikacije možda neće raditi kako treba i obaveštenja mogu da kasne.\n\nAplikacije:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Ograniči"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Želite li da uklonite ograničenje?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Ova aplikacija će moći da koristi bateriju u pozadini. Baterija može da se isprazni ranije od očekivanog."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Ukloni"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Otkaži"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="6097167058237891756">"Aplikacije koriste uobičajenu količinu baterije. Ako aplikacije koriste previše baterije, telefon će vam predložiti radnje koje možete da preduzmete.\n\nUvek možete da uključite Uštedu baterije ako vam je baterija pri kraju."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="573297655597451123">"Aplikacije koriste uobičajenu količinu baterije. Ako aplikacije koriste previše baterije, tablet će vam predložiti radnje koje možete da preduzmete.\n\nUvek možete da uključite Uštedu baterije ako vam je baterija pri kraju."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="8222461068860745749">"Aplikacije koriste uobičajenu količinu baterije. Ako aplikacije koriste previše baterije, uređaj će vam predložiti radnje koje možete da preduzmete.\n\nUvek možete da uključite Uštedu baterije ako vam je baterija pri kraju."</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Menadžer baterije"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Upravljajte aplikacijama automatski"</string>
    <string name="smart_battery_summary" product="default" msgid="1492277404000064998">"Ograničite potrošnju baterije za aplikacije koje ne koristite često"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kada menadžer baterije otkrije da aplikacije prazne bateriju, imate opciju da ograničite te aplikacije. Ograničene aplikacije možda neće raditi kako treba i obaveštenja mogu da kasne."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Ograničene aplikacije"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="6059772951505411003">
      <item quantity="one">Ograničite potrošnju baterije za %1$d aplikaciju</item>
      <item quantity="few">Ograničite potrošnju baterije za %1$d aplikacije</item>
      <item quantity="other">Ograničite potrošnju baterije za %1$d aplikacija</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Ograničena <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3683577206409650564">"Ove aplikacije su trošile bateriju u pozadini. Ograničene aplikacije možda neće raditi kako treba i obaveštenja mogu da kasne."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Koristite menadžer baterije"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Otkrijte kada aplikacije isprazne bateriju"</string>
    <string name="battery_manager_on" product="default" msgid="3197525907390349054">"Uključeno / Otkrivanje kada aplikacije isprazne bateriju"</string>
    <string name="battery_manager_off" msgid="673547668722420924">"Isključeno"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="6714534362166394848">
      <item quantity="one">%1$d aplikacija je ograničena</item>
      <item quantity="few">%1$d aplikacije su ograničene</item>
      <item quantity="other">%1$d aplikacija je ograničeno</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="dialog_stop_title" msgid="5972757101865665655">"Zaustavljate aplikaciju?"</string>
    <string name="dialog_stop_message" product="default" msgid="2063536418875183799">"Telefon ne može da upravlja baterijom na uobičajen način jer mu <xliff:g id="APP">%1$s</xliff:g> ne dozvoljava da pređe u stanje spavanja.\n\nDa biste rešili ovaj problem, možete da zaustavite tu aplikaciju.\n\nAko se ovo dešava i dalje, možda treba da deinstalirate aplikaciju da biste poboljšali performanse baterije."</string>
    <string name="dialog_stop_message" product="tablet" msgid="426862716783569739">"Tablet ne može da upravlja baterijom na uobičajen način jer mu <xliff:g id="APP">%1$s</xliff:g> ne dozvoljava da pređe u stanje spavanja.\n\nDa biste rešili ovaj problem, možete da zaustavite tu aplikaciju.\n\nAko se ovo dešava i dalje, možda treba da deinstalirate aplikaciju da biste poboljšali performanse baterije."</string>
    <string name="dialog_stop_message" product="device" msgid="4252335402634772603">"Uređaj ne može da upravlja baterijom na uobičajen način jer mu <xliff:g id="APP">%1$s</xliff:g> ne dozvoljava da pređe u stanje spavanja.\n\nDa biste rešili ovaj problem, možete da zaustavite tu aplikaciju.\n\nAko se ovo dešava i dalje, možda treba da deinstalirate aplikaciju da biste poboljšali performanse baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="604462000476810125">"Telefon ne može da upravlja baterijom na uobičajen način jer ga <xliff:g id="APP_0">%1$s</xliff:g> stalno budi.\n\nDa biste rešili ovaj problem, možete da zaustavite aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se ovo dešava i dalje, možda treba da deinstalirate aplikaciju da biste poboljšali performanse baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="7737426241260791605">"Tablet ne može da upravlja baterijom na uobičajen način jer ga <xliff:g id="APP_0">%1$s</xliff:g> stalno budi.\n\nDa biste rešili ovaj problem, možete da zaustavite aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se ovo dešava i dalje, možda treba da deinstalirate aplikaciju da biste poboljšali performanse baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="1820679795932901383">"Uređaj ne može da upravlja baterijom na uobičajen način jer ga <xliff:g id="APP_0">%1$s</xliff:g> stalno budi.\n\nDa biste rešili ovaj problem, možete da zaustavite aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se ovo dešava i dalje, možda treba da deinstalirate aplikaciju da biste poboljšali performanse baterije."</string>
    <string name="dialog_stop_ok" msgid="1171516542217183180">"Zaustavi aplikaciju"</string>
    <string name="dialog_background_check_title" msgid="8571605969100408762">"Želite li da isključite korišćenje u pozadini?"</string>
    <string name="dialog_background_check_message" product="default" msgid="6203374578970183277">"Telefon ne može da upravlja baterijom na uobičajen način jer ga <xliff:g id="APP_0">%1$s</xliff:g> stalno budi.\n\nDa biste rešili ovaj problem, možete da zaustavite aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i sprečite je da radi u pozadini."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="1282389215667916176">"Tablet ne može da upravlja baterijom na uobičajen način jer ga <xliff:g id="APP_0">%1$s</xliff:g> stalno budi.\n\nDa biste rešili ovaj problem, možete da zaustavite aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i sprečite je da radi u pozadini."</string>
    <string name="dialog_background_check_message" product="device" msgid="8005524265739819577">"Uređaj ne može da upravlja baterijom na uobičajen način jer ga <xliff:g id="APP_0">%1$s</xliff:g> stalno budi.\n\nDa biste rešili ovaj problem, možete da zaustavite aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i sprečite je da radi u pozadini."</string>
    <string name="dialog_background_check_ok" msgid="5792934035264144797">"Isključi"</string>
    <string name="dialog_location_title" msgid="1323400468370901875">"Želite li da isključite lokaciju?"</string>
    <string name="dialog_location_message" product="default" msgid="5597959072209122057">"Telefon ne može da upravlja baterijom na uobičajen način jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži lokaciju čak i kada ne koristite tu aplikaciju.\n\nDa biste rešili ovaj problem, možete da isključite lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_message" product="tablet" msgid="7165269165194599595">"Tablet ne može da upravlja baterijom na uobičajen način jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži lokaciju čak i kada ne koristite tu aplikaciju.\n\nDa biste rešili ovaj problem, možete da isključite lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_message" product="device" msgid="4606829479989940464">"Uređaj ne može da upravlja baterijom na uobičajen način jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži lokaciju čak i kada ne koristite tu aplikaciju.\n\nDa biste rešili ovaj problem, možete da isključite lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_ok" msgid="6338680851382069716">"Isključi"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekran"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lampa"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="5507921058696341513">"Stanje pripravnosti mobilne mreže"</string>
    <string name="power_phone" msgid="2768396619208561670">"Glasovni pozivi"</string>
    <string name="power_idle" product="tablet" msgid="4689321599298911021">"Tablet je u stanju mirovanja"</string>
    <string name="power_idle" product="default" msgid="9132502722499465252">"Telefon u mirovanju"</string>
    <string name="power_unaccounted" msgid="2160811497426475703">"Razno"</string>
    <string name="power_overcounted" msgid="3681101460287472876">"Prekomerno izračunata"</string>
    <string name="usage_type_cpu" msgid="8544148642836549011">"Ukupno korišćenje procesora"</string>
    <string name="usage_type_cpu_foreground" msgid="6120871498122604239">"Procesor u prednjem planu"</string>
    <string name="usage_type_wake_lock" msgid="3442487584173668904">"Zadrži van stanja spavanja"</string>
    <string name="usage_type_gps" msgid="4118035982288964651">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="5573404832197356206">"Wi-Fi je aktivan"</string>
    <string name="usage_type_phone" product="tablet" msgid="4527092861928972130">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="4149330237181984782">"Telefon"</string>
    <string name="usage_type_data_send" msgid="4375755152437282184">"Poslati mobilni paketi"</string>
    <string name="usage_type_data_recv" msgid="7821924049621005218">"Primljeni mobilni paketi"</string>
    <string name="usage_type_radio_active" msgid="1876069445855950097">"Vreme aktivnosti mobilnog radija"</string>
    <string name="usage_type_data_wifi_send" msgid="6154038607322769558">"Poslati Wi‑Fi paketi"</string>
    <string name="usage_type_data_wifi_recv" msgid="4821128213012023100">"Primljeni Wi‑Fi paketi"</string>
    <string name="usage_type_audio" msgid="1100651355357912864">"Audio"</string>
    <string name="usage_type_video" msgid="1068481638906679035">"Video"</string>
    <string name="usage_type_camera" msgid="3999579307204257822">"Kamera"</string>
    <string name="usage_type_flashlight" msgid="5629235220169383309">"Lampa"</string>
    <string name="usage_type_on_time" msgid="104642441471272535">"Trajanje uključenja"</string>
    <string name="usage_type_no_coverage" msgid="1385712176630900103">"Vreme bez signala"</string>
    <string name="usage_type_total_battery_capacity" msgid="3878234027503885998">"Ukupan kapacitet baterije"</string>
    <string name="usage_type_computed_power" msgid="5191902025833668752">"Izračunata potrošnja energije"</string>
    <string name="usage_type_actual_power" msgid="1221358930299037926">"Zabeležena potrošnja energije"</string>
    <string name="battery_action_stop" msgid="6998228610098034316">"Prinudno zaustavi"</string>
    <string name="battery_action_app_details" msgid="7201369216798227707">"Informacije o aplikaciji"</string>
    <string name="battery_action_app_settings" msgid="2437124469335488464">"Podešavanja aplikacija"</string>
    <string name="battery_action_display" msgid="6515712081248863749">"Podešavanja ekrana"</string>
    <string name="battery_action_wifi" msgid="1829212604573932607">"Wi-Fi podešavanja"</string>
    <string name="battery_action_bluetooth" msgid="4723692623358386789">"Podešavanja za Bluetooth"</string>
    <string name="battery_desc_voice" msgid="6900799826084022585">"Baterija koju koriste glasovni pozivi"</string>
    <string name="battery_desc_standby" product="tablet" msgid="5818742458684767043">"Iskorišćena baterija kada je tablet neaktivan"</string>
    <string name="battery_desc_standby" product="default" msgid="2543075041964578103">"Baterija koja se koristi u stanju mirovanja"</string>
    <string name="battery_desc_radio" msgid="454677140485133914">"Baterija koju koristi mobilni radio"</string>
    <string name="battery_sugg_radio" msgid="5476234634503535270">"Pređite na režim rada u avionu kako bi se sačuvala baterija u oblastima bez pokrivenosti mrežom"</string>
    <string name="battery_desc_flashlight" msgid="6694895513133361404">"Energija baterije koju troši lampa"</string>
    <string name="battery_desc_camera" msgid="6152712271731518018">"Procenat baterije koji troši kamera"</string>
    <string name="battery_desc_display" msgid="7175017688954602685">"Baterija koju koristi ekran i pozadinsko svetlo"</string>
    <string name="battery_sugg_display" msgid="3102137296547788111">"Smanjite osvetljenost i/ili vreme do gašenja ekrana"</string>
    <string name="battery_desc_wifi" msgid="5276669172548928768">"Baterija koju koristi Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="359757575108350109">"Isključite Wi-Fi kada ga ne koristite ili kada nije dostupan"</string>
    <string name="battery_desc_bluetooth" msgid="2237947137783306282">"Baterija koju koristi Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="8943564578546832037">"Isključite Bluetooth kada ga ne koristite"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="6495519793211758353">"Pokušajte da se povežete sa drugim Bluetooth uređajem"</string>
    <string name="battery_desc_apps" msgid="4187483940383266017">"Baterija koju koristi aplikacija"</string>
    <string name="battery_sugg_apps_info" msgid="4796917242296658454">"Zaustavite ili deinstalirajte aplikaciju"</string>
    <string name="battery_sugg_apps_gps" msgid="7221335088647925110">"Izaberite režim uštede baterije"</string>
    <string name="battery_sugg_apps_settings" msgid="6527223370162382166">"Aplikacija može da ponudi podešavanja kako bi se smanjilo korišćenje baterije"</string>
    <string name="battery_desc_users" msgid="1959428568888686847">"Baterija koju koristi korisnik"</string>
    <string name="battery_desc_unaccounted" msgid="1649497860893660763">"Raznovrsna potrošnja energije"</string>
    <string name="battery_msg_unaccounted" msgid="5647345548624995064">"Potrošnja baterije je približna vrednost potrošnje energije i ne obuhvata svaki izvor pražnjenja baterije. Raznovrsna potrošnja predstavlja razliku između izračunate približne potrošnje baterije i stvarne potrošnje zabeležene za bateriju."</string>
    <string name="battery_desc_overcounted" msgid="5982079150027267539">"Prekomerno izračunata potrošnja energije"</string>
    <string name="mah" msgid="3604527474433227780">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="6401552215008504483">"Koristi se <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="4416277218863232476">"Aktivnost: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Korišćenje ekrana: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> koristi <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> ukupnog kapaciteta baterije"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Pregled od poslednjeg potpunog punjenja"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Poslednje potpuno punjenje"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Puna baterija traje oko"</string>
    <string name="battery_footer_summary" msgid="9125397752380281832">"Podaci o korišćenju baterije su približni i mogu da se menjaju u zavisnosti od načina korišćenja"</string>
    <string name="battery_detail_foreground" msgid="3312280147931093967">"U aktivnoj upotrebi"</string>
    <string name="battery_detail_background" msgid="3333915023706228000">"U pozadini"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Potrošnja baterije"</string>
    <string name="battery_detail_info_title" msgid="5896661833554333683">"Od potpunog punjenja"</string>
    <string name="battery_detail_manage_title" msgid="7910805419446927887">"Upravljanje potrošnjom baterije"</string>
    <string name="advanced_battery_graph_subtext" msgid="6816737986172678550">"Procena preostalog nivoa napunjenosti baterije je zasnovana na korišćenju uređaja"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Procenjeno preostalo vreme"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Do potpunog punjenja"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Procena može da se menja u zavisnosti od korišćenja"</string>
    <string name="menu_stats_unplugged" msgid="7125297366200634285">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od isključivanja"</string>
    <string name="menu_stats_last_unplugged" msgid="230678127178268655">"Tokom poslednjeg isključivanja za <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="2713445396954503670">"Ukupno korišćeno"</string>
    <string name="menu_stats_refresh" msgid="6727628139586938835">"Osveži"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Medija server"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimizacija aplikacija"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Ušteda baterije"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Automatski uključi"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Nema rasporeda"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Na osnovu rutine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Na osnovu procenta"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Ušteda baterije se uključuje ako će baterija verovatno da se isprazni pre sledećeg tipičnog punjenja"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Uključuje se na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Podesite raspored"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Produžite trajanje baterije"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Isključi kada se napuni"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="6862168106613838677">"Ušteda baterije se isključuje kada je telefon na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6740553373344759992">"Ušteda baterije se isključuje kada je tablet na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8512106347424406909">"Ušteda baterije se isključuje kada je uređaj na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Uključi"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Koristi Uštedu baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Automatski uključi"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikada"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"na <xliff:g id="PERCENT">%1$s</xliff:g> baterije"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Procenat napunjenosti baterije"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Prikaži procenat napunjenosti baterije na statusnoj traci"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistika procesa"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Štreberska statistika o aktivnim procesima"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Iskorišćenost memorije"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> od <xliff:g id="TOTALRAM">%2$s</xliff:g> je upotrebljeno za poslednja/ih <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> RAM memorije je upotrebljeno tokom <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"U pozadini"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"U prvom planu"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Keširano"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Izvorni"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Jezgro"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Keševi"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Upotreba RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Upotreba RAM-a (u pozadini)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Trajanje"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesi"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Usluge"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Trajanje"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detalji memorije"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 sata"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 sati"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 sati"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 dan"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Prikaži sistemske"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Sakrij sistemske"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Prikazivanje procenata"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Koristi jedinstvenu veličinu skupa"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Tip statističkih podataka"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"U pozadini"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"U prvom planu"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Keširano"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Glasovni unos i izlaz"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Podešavanja glasovnog unosa i izlaza"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Glasovna pretraga"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android tastatura"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Podešavanja glasovnog unosa"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Glasovni unos"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Usluge glasovnog unosa"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Cela aktuelna reč i interakcija"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Jednostavan govor u tekst"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Ova usluga glasovnog unosa će moći umesto vas da obavlja konstantno glasovno praćenje i kontroliše aplikacije u kojima je omogućen glas. Ona je deo aplikacije <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Želite li da omogućite korišćenje ove usluge?"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Željeni mehanizam"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Podešavanja mehanizma"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Brzina i jačina govora"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Mehanizam"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Govorni jezik"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instaliranje glasova"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Nastavite na aplikaciju <xliff:g id="TTS_APP_NAME">%s</xliff:g> da biste instalirali glasove"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Otvori aplikaciju"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Otkaži"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Resetuj"</string>
    <string name="tts_play" msgid="2945513377250757221">"Pusti"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Prilagodljivo povezivanje"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Produžuje trajanje baterije i poboljšava učinak uređaja tako što automatski upravlja mrežnim vezama"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Skladište akreditiva"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instaliraj sertifikat"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="6644116499934553975">"Instaliraj sertifikate iz memorije"</string>
    <string name="credentials_install_summary" product="default" msgid="8161351950524166012">"Instaliranje sertifikata sa SD kartice"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Brisanje akreditiva"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Uklanjanje svih sertifikata"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Pouzdani akreditivi"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Prikaži pouzdane CA sertifikate"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Korisnički akreditivi"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Pregledajte i menjajte sačuvane akreditive"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Napredna"</string>
    <string name="credential_storage_type" msgid="930861336971619888">"Tip memorijskog prostora"</string>
    <string name="credential_storage_type_hardware" msgid="2630040425119817220">"Podržan hardverom"</string>
    <string name="credential_storage_type_software" msgid="4786996040468294626">"Samo softverski"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Akreditivi nisu dostupni za ovog korisnika"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instalirano za VPN i aplikacije"</string>
    <string name="credential_for_wifi" msgid="1963335263280604998">"Instalirano za Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Želite li da uklonite sav sadržaj?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Skladište akreditiva je izbrisano."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Nije moguće obrisati skladište akreditiva."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apl. sa pristupom podacima o korišćenju"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA sertifikat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Korisnički sertifikat za VPN i aplikaciju"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Sertifikat za Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Podaci neće biti privatni"</string>
    <string name="ca_certificate_warning_description" msgid="3386740654961466569">"Veb-sajtovi, aplikacije i VPN-ovi koriste CA sertifikate za šifrovanje. Instalirajte CA sertifikate samo iz organizacija u koje imate poverenja. \n\n Ako instalirate CA sertifikat, vlasnik sertifikata bi mogao da pristupi podacima, poput lozinki ili podataka o kreditnoj kartici, sa veb-sajtova koje posećujete ili iz aplikacija koje koristite – čak i ako su ti podaci šifrovani."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ne instaliraj"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Ipak instaliraj"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikat nije instaliran"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signal za hitne pozive"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Podešavanje ponašanja kada se uspostavlja hitan poziv"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Rezervne kopije"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Uključeno"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Isključeno"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Rezervna kopija i resetovanje"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Lični podaci"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Pravljenje rezervnih kopija podataka"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Pravi rezervne kopije podataka o aplikacijama, Wi-Fi lozinki i drugih podešavanja na Google serverima"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Rezervna kopija naloga"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Upravljajte nalogom za rezervne kopije"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Uvrštavanje podataka aplikacija"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatsko vraćanje"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Kada se aplikacija ponovo instalira, vrati rezervne kopije podešavanja i podataka"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Usluga pravljenja rezervnih kopija nije aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Trenutno nijedan nalog ne čuva rezervne kopije podataka"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Želite li da zaustavite pravljenje rezervnih kopija Wi-Fi lozinki, obeleživača, ostalih podešavanja i podataka o aplikacijama, kao i da izbrišete sve kopije na Google serverima?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Želite li da zaustavite pravljenje rezervnih kopija podataka uređaja (poput Wi-Fi lozinki i istorije poziva) i podataka aplikacija (poput podešavanja i datoteka sačuvanih u aplikacijama) i izbrišete sve kopije na udaljenim serverima?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Automatski pravite rezervne kopije podataka uređaja (poput Wi-Fi lozinki i istorije poziva) i podataka aplikacija (poput podešavanja i datoteka sačuvanih u aplikacijama) daljinski.\n\nKada uključite automatsko pravljenje rezervnih kopija, podaci uređaja i aplikacija se povremeno čuvaju daljinski. Podaci aplikacija mogu da budu bilo koji podaci koje je aplikacija sačuvala (na osnovu podešavanja programera), uključujući potencijalno osetljive podatke kao što su kontakti, poruke i slike."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Podešavanja administratora uređaja"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplikacija za administratora uređaja"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktiviraj ovu aplikaciju za administratora uređaja"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Deinstaliraj aplikaciju"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktiviraj i deinstaliraj"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplikacije za administratora"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nema dostupnih aplikacija za administratora uređaja"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nema dostupnih pouzdanih agenata"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktiviraj aplikaciju za administratore?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiviraj ovu aplikaciju za administratore uređaja"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrator uređaja"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Aktiviranje ove aplikacije za administratore omogućiće aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da obavi sledeće operacije:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"<xliff:g id="APP_NAME">%1$s</xliff:g> će upravljati ovim uređajem i štititi ga."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Ova aplikacija za administratora je aktivna i omogućava aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da obavi sledeće operacije:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Aktivirati Menadžera profila?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Želite li da dozvolite nadzor?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ako nastavite, korisnikom će upravljati administrator, koji će možda moći da čuva i povezane podatke, pored ličnih podataka.\n\nAdministrator može da prati podešavanja, pristup, aplikacije i podatke povezane sa ovim korisnikom, uključujući aktivnosti na mreži i informacije o lokaciji uređaja, kao i da upravlja njima."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Administrator je onemogućio druge opcije"</string>
    <string name="admin_more_details" msgid="6698424974827333973">"Još detalja"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Evidencija obaveštenja"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Istorija obaveštenja"</string>
    <string name="notification_history_today" msgid="5828496957208237230">"Poslednja 24 sata"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Odloženo"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nedavno odbačeno"</string>
    <plurals name="notification_history_count" formatted="false" msgid="1859304685071321991">
      <item quantity="one"><xliff:g id="NUMBER_1">%d</xliff:g> obaveštenje</item>
      <item quantity="few"><xliff:g id="NUMBER_1">%d</xliff:g> obaveštenja</item>
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> obaveštenja</item>
    </plurals>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Melodija zvona i vibracija poziva"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Mrežni detalji"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinhronizacija je omogućena"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinhronizacija je onemogućena"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sinhronizacija je u toku"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Greška pri sinhronizaciji."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinhronizacija nije uspela"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinhronizacija je aktivna"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinhronizacija"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sinhronizacija trenutno ima problema. Uskoro će se vratiti."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Dodaj nalog"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Poslovni profil još uvek nije dostupan"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Poslovni profil"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Ovim upravlja organizacija"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Aplikacije i obaveštenja su isključeni"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Ukloni poslovni profil"</string>
    <string name="background_data" msgid="321903213000101158">"Podaci o pozadini"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikacije uvek mogu da sinhronizuju, šalju i primaju podatke"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Želite da onemogućite pozadinske podatke?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Ako onemogućite pozadinske podatke, baterija će trajati duže, a korišćenje podataka će biti manje. Neke aplikacije će možda i dalje koristiti vezu sa pozadinskim podacima."</string>
    <string name="sync_automatically" msgid="4874122892765430304">"Automat. sinhronizuj podatke apl."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinhron. je UKLJUČENA"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinhr. je ISKLJUČENA"</string>
    <string name="sync_error" msgid="846923369794727644">"Greška pri sinhron."</string>
    <string name="last_synced" msgid="1527008461298110443">"Sinhronizovano: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sinhronizacija je u toku..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Napravi rezervnu kopiju podešavanja"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Pravljenje rezervne kopije podešavanja"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinhronizuj odmah"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Otkaži sinhronizaciju"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Dodirnite da biste sinhronizovali odmah <xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalendar"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakti"</string>
    <string name="sync_plug" msgid="7956982719077985381"><font fgcolor="#ffffffff">"Dobro došli u Google sinhronizaciju!"</font>\n"Google-ov pristup sinhronizovanju podataka kako bi se omogućio pristup kontaktima, obavezama i još mnogo čemu bez obzira na to gde se nalazite."</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Podešavanja sinhronizacije aplikacija"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Podaci i sinhronizacija"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Promenite lozinku"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Podešavanja naloga"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Ukloni nalog"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Dodajte nalog"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Želite li da uklonite nalog?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="8893801622174947887">"Uklanjanjem ovog naloga izbrisaćete sve poruke, kontakte i druge podatke sa tableta!"</string>
    <string name="really_remove_account_message" product="default" msgid="1217810840427479274">"Uklanjanjem ovog naloga izbrisaćete sve poruke, kontakte i druge podatke sa telefona!"</string>
    <string name="really_remove_account_message" product="device" msgid="5241756807386611084">"Ako uklonite ovaj nalog, izbrisaćete sve poruke, kontakte i druge podatke sa uređaja!"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Administrator ne dozvoljava ovu promenu"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Ručno sinhronizovanje nije moguće"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Sinhronizacija za ovu stavku je trenutno onemogućena. Da biste promenili ovo podešavanje, privremeno uključite pozadinske podatke i automatsku sinhronizaciju."</string>
    <string name="enter_password" msgid="6327051330258595331">"Da biste pokrenuli Android, unesite lozinku"</string>
    <string name="enter_pin" msgid="1029287617551232681">"Da biste pokrenuli Android, unesite PIN"</string>
    <string name="enter_pattern" msgid="1747316785866742960">"Da biste pokrenuli Android, nacrtajte šablon"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="340747269176120242">"Pogrešan šablon"</string>
    <string name="cryptkeeper_wrong_password" msgid="7295607881887114486">"Pogrešna lozinka"</string>
    <string name="cryptkeeper_wrong_pin" msgid="2347961593970714201">"Pogrešan PIN"</string>
    <string name="checking_decryption" msgid="6111642972615688237">"Proverava se..."</string>
    <string name="starting_android" msgid="6694154070215356186">"Pokrećemo Android..."</string>
    <string name="delete" msgid="8330605554706263775">"Izbriši"</string>
    <string name="misc_files" msgid="6598066985800749585">"Razne datoteke"</string>
    <string name="misc_files_selected_count" msgid="5597802791672749532">"izabrano je <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="7622766714974500289">"<xliff:g id="NUMBER">%1$s</xliff:g> od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="7898929601615536401">"Izaberi sve"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Korišćenje podataka"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobilni podaci i Wi‑Fi"</string>
    <string name="data_usage_accounting" msgid="6832015632699116754">"Obračun podataka kod mobilnog operatera se možda razlikuje od vašeg uređaja."</string>
    <string name="data_usage_app" msgid="6367974637783240699">"Korišćenje aplikacije"</string>
    <string name="data_usage_app_info_label" msgid="3542220416056122841">"INFORMACIJE O APLIKACIJI"</string>
    <string name="data_usage_cellular_data" msgid="1917226172511825849">"Mobilni podaci"</string>
    <string name="data_usage_data_limit" msgid="1120291692444009289">"Podešavanje ograničenja za podatke"</string>
    <string name="data_usage_cycle" msgid="6875568429140150029">"Ciklus potrošnje podataka"</string>
    <string name="data_usage_app_items_header_text" msgid="7513812163443595033">"Korišćenje aplikacije"</string>
    <string name="data_usage_menu_roaming" msgid="6864561338842056939">"Prenos podataka u romingu"</string>
    <string name="data_usage_menu_restrict_background" msgid="1414574366645086133">"Ograniči pozadinske podatake"</string>
    <string name="data_usage_menu_allow_background" msgid="6242931073390680432">"Dozvoli pozadinske podatke"</string>
    <string name="data_usage_menu_split_4g" msgid="3391899816926640583">"Odvoji potrošnju 4G podataka"</string>
    <string name="data_usage_menu_show_wifi" msgid="6380926350184939975">"Prikaži Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="4694889089278302691">"Sakrij Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="4401026240876938859">"Prikaži upotrebu Eterneta"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="7792365022467586772">"Sakrij korišćenje eterneta"</string>
    <string name="data_usage_menu_metered" msgid="4279260736172851951">"Mrežna ograničenja"</string>
    <string name="data_usage_menu_auto_sync" msgid="2632694000068175025">"Automatski sinhronizuj podatke"</string>
    <string name="data_usage_menu_sim_cards" msgid="8966135605336735887">"SIM kartice"</string>
    <string name="data_usage_cellular_data_summary" msgid="8139993171126153316">"Pauzirano je na ograničenju"</string>
    <string name="account_settings_menu_auto_sync" msgid="1660484779001900562">"Automatski sinhronizuj podatke"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Autom. sinhron. lične podatke"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Autom. sinhr. podatke za posao"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Promena ciklusa..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dan u mesecu kada se ponovo postavlja ciklus potrošnje podataka:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"U ovom periodu aplikacije nisu koristile podatke."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Prvi plan"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Pozadina"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"ograničena"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Želite da onemogućite mobilne podatke?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Podesi ograničenje za mobil. pod."</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Podesi ograničenje za 4G podatke"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Podesi ograničenje za 2G-3G podatke"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Ograniči Wi-Fi podatke"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Eternet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilni"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobilne"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Nijedna"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Podaci mobilne mreže"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G-3G podaci"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G podaci"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"U prvom planu:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"U pozadini:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Podešavanja aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Pozadinski podaci"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Omogući korišćenje mobilnih podataka u pozadini"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Za ograničenje pozadinskih podataka za ovu apl. prvo ograničite mobilne podatke."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Želite li da ograničite pozadinske podatke?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Ova funkcija može da zaustavi aplikaciju koja zavisi od pozadinskih podataka kada su dostupne samo mobilne mreže.\n\nAdekvatnije kontrole za korišćenje podataka možete da pronađete u podešavanjima dostupnim u okviru aplikacije."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Ograničavanje pozadinskih podataka je moguće samo kada budete podesili ograničenje za mobilne podatke."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Uključujete auto. sinhronizaciju?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="6387714350903085918">"Sve promene koje unesete na naloge na vebu će automatski biti kopirane na tablet.\n\nNeki nalozi mogu i automatski da kopiraju na veb sve promene koje unesete na tabletu. Tako funkcioniše Google nalog."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="6457107552266187107">"Sve promene koje unesete na naloge na vebu će automatski biti kopirane na telefon.\n\nNeki nalozi mogu i automatski da kopiraju na veb sve promene koje unesete na telefonu. Tako funkcioniše Google nalog."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Isključujete auto-sinh. podataka?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"To će se smanjiti potrošnju podataka i baterije, ali biće potrebno da ručno sinhronizujete svaki nalog da biste prikupili nedavne informacije. Nećete primati ni obaveštenja kada dođe do ažuriranja."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Datum vraćanja ciklusa potrošnje na početne vrednosti"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Datum svakog meseca:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Podesi"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Podešavanje upozorenja o korišćenju podataka"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Podešavanje ograničenja za korišćenje podataka"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Ograničavanje potrošnje podataka"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="6000062970083379466">"Tablet će isključiti mobilne podatke čim dostigne ograničenje koje ste podesili.\n\nPošto potrošnju podataka meri tablet, a mobilni operater može drugačije da računa potrošnju, razmislite o tome da podesite niže ograničenje."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="4942895670789168024">"Telefon će isključiti mobilne podatke čim dostigne ograničenje koje ste podesili.\n\nPošto potrošnju podataka meri telefon, a mobilni operater može drugačije da računa potrošnju, razmislite o tome da podesite niže ograničenje."</string>
    <string name="data_usage_restrict_background_title" msgid="2745551538820692821">"Želite li da ograničite pozadinske podatke?"</string>
    <string name="data_usage_restrict_background" msgid="1893102079135282794">"Ako ograničite mobilne pozadinske podatke, neke aplikacije i usluge neće funkcionisati ako niste povezani sa Wi-Fi-jem."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="5588623586867665419">"Ako ograničite mobilne pozadinske podatke, neke aplikacije i usluge neće funkcionisati ako niste povezani sa Wi-Fi-jem.\n\nOvo podešavanje utiče na sve korisnike na ovom tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="6402714504088590463">"Ako ograničite mobilne pozadinske podatke, neke aplikacije i usluge neće funkcionisati ako niste povezani sa Wi-Fi-jem.\n\nOvo podešavanje utiče na sve korisnike na ovom telefonu."</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="12">"upoz."</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="12">"ogran."</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Uklonjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Uklonjene aplikacije i korisnici"</string>
    <string name="data_usage_received_sent" msgid="1486740779864806124">"Primljenih: <xliff:g id="RECEIVED">%1$s</xliff:g>, poslatih: <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="2695893609573024612">"<xliff:g id="RANGE">%2$s</xliff:g>: Iskorišćeno je oko <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="45300375132284265">"<xliff:g id="RANGE">%2$s</xliff:g>: Tablet je izmerio da je iskorišćeno oko <xliff:g id="TOTAL">%1$s</xliff:g>. Operater možda drugačije meri."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="3183594094081558193">"<xliff:g id="RANGE">%2$s</xliff:g>: Telefon je izmerio da je iskorišćeno oko <xliff:g id="TOTAL">%1$s</xliff:g>. Operater možda drugačije meri."</string>
    <string name="data_usage_metered_title" msgid="6421347352444253058">"Mrežna ograničenja"</string>
    <string name="data_usage_metered_body" msgid="1206840367501998582">"Mreže sa ograničenjem se tretiraju kao mobilne mreže kada postoji ograničenje za pozadinske podatke. Aplikacije mogu da vas upozore kada nameravate da koristite te mreže za velika preuzimanja."</string>
    <string name="data_usage_metered_mobile" msgid="3514227339274396401">"Mobilne mreže"</string>
    <string name="data_usage_metered_wifi" msgid="4807465959110473407">"Wi‑Fi mreže sa ograničenjem"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="4664158157415362613">"Da biste izabrali mreže sa ograničenjem, uključite Wi-Fi."</string>
    <string name="data_usage_metered_auto" msgid="1560514082131687116">"Automatski"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Korišćenje mreže"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Sa ograničenjem"</string>
    <string name="data_usage_metered_no" msgid="1685828958417926268">"Bez ograničenja"</string>
    <string name="data_usage_disclaimer" msgid="3271450299386176770">"Obračun podataka kod mobilnog operatera se možda razlikuje od vašeg uređaja."</string>
    <string name="cryptkeeper_emergency_call" msgid="8369322820475703306">"Hitan poziv"</string>
    <string name="cryptkeeper_return_to_call" msgid="3857250752781151232">"Nazad na poziv"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Naziv"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tip"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa servera"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP šifrovanje (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Tajni L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"IPSec unapred deljeni ključ"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec sertifikat korisnika"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec CA sertifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec sertifikat servera"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Prikaži napredne opcije"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"DNS domeni za pretragu"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS serveri (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Rute za prosleđivanje (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Korisničko ime"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Lozinka"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Sačuvaj informacije o nalogu"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ne koristi se)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ne verifikuj server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(primljeno sa servera)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Ovaj tip VPN-a ne može uvek da ostane povezan"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Uvek uključeni VPN podržava samo numeričke adrese servera"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"DNS server mora da se odredi za uvek uključeni VPN"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Adrese DNS servera moraju da budu numeričke za uvek uključeni VPN"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Unete informacije ne podržavaju uvek uključeni VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Otkaži"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Odbaci"</string>
    <string name="vpn_save" msgid="683868204634860888">"Sačuvaj"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Poveži"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Zameni"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Izmena VPN profila"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Zaboravi"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Povezivanje na profil <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Želite li da prekinete vezu sa ovim VPN-om?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Prekini vezu"</string>
    <string name="vpn_version" msgid="41856553718304367">"Verzija <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Zaboravi VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Želite li da zamenite postojeći VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Želite li da podesite uvek uključeni VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Kada je ovo podešavanje uključeno, nećete imati internet vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Postojeći VPN će biti zamenjen i nećete imati internet vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Već ste povezani sa uvek uključenim VPN-om. Ako se povežete sa nekim drugim, postojeći VPN će biti zamenjen, a režim Uvek uključen će biti isključen."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Već ste povezani sa VPN-om. Ako se povežete sa nekim drugim, postojeći VPN će biti zamenjen."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Uključi"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Povezivanje sa VPN-om <xliff:g id="VPN_NAME">%1$s</xliff:g> nije uspelo"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Ova aplikacija ne podržava uvek uključeni VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Dodavanje VPN profila"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Izmeni profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Izbriši profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Stalno uključen VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Niste dodali nijedan VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Nikada ne prekidaj vezu sa VPN-om"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Ova aplikacija ne podržava"</string>
    <string name="vpn_always_on_summary_active" msgid="2532123735674813569">"Uvek uključeni VPN je aktivan"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokiraj veze bez VPN-a"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Treba vam VPN veza?"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Izaberite VPN profil sa kojim ćete uvek biti povezani. Mrežni sadržaj će biti dozvoljen samo kada ste povezani sa ovim VPN-om."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Nijedan"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Stalno uključen VPN zahteva IP adresu za server i DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nije uspostavljena mrežna veza. Probajte ponovo kasnije."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Veza sa VPN-om je prekinuta"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Ništa"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Nedostaje sertifikat. Pokušajte da izmenite profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Korisnik"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Onemogući"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Omogući"</string>
    <string name="trusted_credentials_remove_label" msgid="8975881053042174913">"Ukloni"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Imaj poverenja"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Želite li da omogućite sistemski CA sertifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Želite li da onemogućite sistemski CA sertifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Želite da trajno uklonite CA sertifikat korisnika?"</string>
    <string name="credential_contains" msgid="407972262032275476">"Ovaj unos obuhvata:"</string>
    <string name="one_userkey" msgid="4417212932385103517">"jedan korisnički ključ"</string>
    <string name="one_usercrt" msgid="1865069301105101370">"jedan sertifikat korisnika"</string>
    <string name="one_cacrt" msgid="7467796501404158399">"jedan CA sertifikat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA sertifikata"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detalji akreditiva"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Uklonjen je akreditiv: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nema instaliranih korisničkih akreditiva"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Provera pravopisa"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Provera pravopisa za posao"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Ovde unesite trenutnu lozinku za pravljenje rezervne kopije čitavog sistema"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Ovde unesite novu lozinku za pravljenje rezervnih kopija čitavog sistema"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Unesite ponovo novu lozinku za rezervnu kopiju čitavog sistema"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Postavi lozinku rezervne kopije"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Otkaži"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Dodatna ažuriranja sistema"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Mreža se možda nadgleda"</string>
    <string name="done_button" msgid="6269449526248267">"Gotovo"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="5491460811755938449">
      <item quantity="one">Označite sertifikate kao pouzdane ili ih uklonite</item>
      <item quantity="few">Označite sertifikate kao pouzdane ili ih uklonite</item>
      <item quantity="other">Označite sertifikate kao pouzdane ili ih uklonite</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="2788832560436163252">
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instalirao autoritete za izdavanje sertifikata na uređaju, što može da mu omogući da prati aktivnosti uređaja na mreži, uključujući imejlove, aplikacije i bezbedne veb-sajtove.\n\nKontaktirajte administratora da biste dobili više informacija o ovim sertifikatima.</item>
      <item quantity="few"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirala autoritete za izdavanje sertifikata na uređaju, što može da im omogući da prate aktivnosti uređaja na mreži, uključujući imejlove, aplikacije i bezbedne veb-sajtove.\n\nKontaktirajte administratora da biste dobili više informacija o ovim sertifikatima.</item>
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirala autoritete za izdavanje sertifikata na uređaju, što može da im omogući da prate aktivnosti uređaja na mreži, uključujući imejlove, aplikacije i bezbedne veb-sajtove.\n\nKontaktirajte administratora da biste dobili više informacija o ovim sertifikatima.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="3989916958347169622">
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instalirao autoritete za izdavanje sertifikata za poslovni profil, što može da mu omogući da prati aktivnosti na poslovnoj mreži, uključujući imejlove, aplikacije i bezbedne veb-sajtove.\n\nKontaktirajte administratora da biste dobili više informacija o ovim sertifikatima.</item>
      <item quantity="few"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirala autoritete za izdavanje sertifikata na uređaju, što može da im omogući da prate aktivnosti uređaja na mreži, uključujući imejlove, aplikacije i bezbedne veb-sajtove.\n\nKontaktirajte administratora da biste dobili više informacija o ovim sertifikatima.</item>
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirala autoritete za izdavanje sertifikata na uređaju, što može da im omogući da prate aktivnosti uređaja na mreži, uključujući imejlove, aplikacije i bezbedne veb-sajtove.\n\nKontaktirajte administratora da biste dobili više informacija o ovim sertifikatima.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Treća strana može da prati vašu aktivnost na mreži, uključujući e-poštu, aplikacije i bezbedne veb-sajtove.\n\nTo omogućava pouzdani akreditiv koji je instaliran na uređaju."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="125941406175485894">
      <item quantity="one">Proveri sertifikate</item>
      <item quantity="few">Proveri sertifikate</item>
      <item quantity="other">Proveri sertifikate</item>
    </plurals>
    <string name="user_settings_title" msgid="6550866465409807877">"Više korisnika"</string>
    <string name="user_settings_footer_text" product="device" msgid="7523914344521302179">"Delite uređaj tako što ćete dodati nove korisnike. Svaki korisnik ima lični prostor na uređaju za prilagođene početne ekrane, naloge, aplikacije, podešavanja i drugo."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="3730074318510244552">"Delite tablet tako što ćete dodati nove korisnike. Svaki korisnik ima lični prostor na tabletu za prilagođene početne ekrane, naloge, aplikacije, podešavanja i drugo."</string>
    <string name="user_settings_footer_text" product="default" msgid="4420915712050349125">"Delite telefon tako što ćete dodati nove korisnike. Svaki korisnik ima lični prostor na telefonu za prilagođene početne ekrane, naloge, aplikacije, podešavanja i drugo."</string>
    <string name="user_list_title" msgid="1387379079186123404">"Korisnici i profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Dodaj korisnika ili profil"</string>
    <string name="user_add_user_menu" msgid="6395904234221724625">"Dodaj korisnika"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Ograničeni profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nije podešeno"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Nije podešen – Ograničeni profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nije podešeno – poslovni profil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="3763630194459958977">"Nadimak"</string>
    <string name="user_add_max_count" msgid="5739771048517070983">"Možete da dodate najviše <xliff:g id="USER_COUNT">%1$d</xliff:g> korisnika"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="3405022988077682357">"Samo vlasnik tableta može da upravlja korisnicima."</string>
    <string name="user_cannot_manage_message" product="default" msgid="6434662649769855494">"Samo vlasnik telefona može da upravlja korisnicima."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Ograničeni profili ne mogu da dodaju naloge"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Izbriši <xliff:g id="USER_NAME">%1$s</xliff:g> sa uređaja"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Podešavanja zaključanog ekrana"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Dodajte korisnike sa zaključanog ekrana"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Želite li da izbrišete sebe?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Brišete ovog korisnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Uklanjate ovaj profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Ukloniti poslovni profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="439222554798995592">"Izgubićete prostor i podatke na ovom tabletu. Ne možete da opozovete ovu radnju."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5991495192044543230">"Izgubićete prostor i podatke na ovom telefonu. Ne možete da opozovete ovu radnju."</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Sve aplikacije i podaci sa ovog profila biće izbrisani ako nastavite."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Dodavanje novog korisnika..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Brisanje korisnika"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Izbriši"</string>
    <string name="user_guest" msgid="4545590092001460388">"Gost"</string>
    <string name="user_exit_guest_title" msgid="2653103120908427236">"Ukloni gosta"</string>
    <string name="user_exit_guest_confirm_title" msgid="1284823459630164754">"Želite li da uklonite gosta?"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Sve aplikacije i podaci u ovoj sesiji će biti izbrisani."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Ukloni"</string>
    <string name="user_enable_calling" msgid="264875360626905535">"Uključi telefonske pozive"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Uključi telefonske pozive i SMS"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Izbrišite korisnika"</string>
    <string name="user_enable_calling_confirm_title" msgid="7868894792723368364">"Želite li da uključite telefonske pozive?"</string>
    <string name="user_enable_calling_confirm_message" msgid="4924965198409050155">"Istorija poziva će biti deljena sa ovim korisnikom."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Uključujete telefonske pozive i SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Istorija poziva i SMS-ova će se deliti sa ovim korisnikom."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informacije za hitni slučaj"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informacije i kontakti za: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Dozvole za aplikacije i sadržaj"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikacije sa ograničenjima"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Proširi podešavanja aplikacije"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Beskontaktna plaćanja"</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Kako to funkcioniše"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Platite pomoću telefona u prodavnicama"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Podrazumevano za plaćanje"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nije podešeno"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="788899906312142803">"Koristi podrazumevano"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Uvek"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Osim kad je otvorena druga aplikacija za plaćanje"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Na terminalu za beskontaktno plaćanje koristiće se:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Plaćanje na terminalu"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Podesite aplikaciju za plaćanje. Zatim samo zadržite zadnji deo telefona pored bilo kog terminala sa simbolom za povezivanje bez kontakta."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Važi"</string>
    <string name="nfc_more_title" msgid="4202405349433865488">"Još..."</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Podesite podrazumevanu aplikaciju za plaćanje"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Ažurirajte podrazumevanu aplikaciju za plaćanje"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Na terminalu za beskontaktno plaćanje koristiće se <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Na terminalu za beskontaktno plaćanje koristiće se <xliff:g id="APP_0">%1$s</xliff:g>.\n\nTo znači da <xliff:g id="APP_1">%2$s</xliff:g> više neće biti podrazumevana aplikacija za plaćanje."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Podesi kao podrazumevano"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Ažuriraj"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Ograničenja"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Ukloni ograničenja"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Promeni PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Pomoć i povratne inf."</string>
    <string name="support_summary" msgid="1034146931237148885">"Članci pomoći, podrška telefonom i ćaskanjem, početni koraci"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Nalog za sadržaj"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID slike"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Ekstremne opasnosti"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Prijem obaveštenja o ekstremnoj opasnosti po život i imovinu"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ozbiljne opasnosti"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Prijem obaveštenja o ozbiljnoj opasnosti po život i imovinu"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER obaveštenja"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Prijem objava o kidnapovanju dece"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Ponavljanje"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Omogući Menadžer poziva"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Omogućite ovoj usluzi da upravlja načinom na koji se upućuju pozivi."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Menadžer poziva"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Bežična upozorenja o hitnim slučajevima"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Mrežni operateri"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Nazivi pristupnih tačaka"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Napredno pozivanje"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G pozivanje"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="6776190202179584104">"Korišćenje LTE usluga za poboljšanje glasovnih i drugih komunikacija (preporučeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="7814006095552641136">"Koristi 4G usluge za poboljšanje glasovne i druge komunikacije (preporučeno)"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Šalji kontakte mobilnom operateru"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Šalje brojeve telefona kontakata radi pružanja poboljšanih funkcija"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Želite da šaljete kontakte mobilnom operateru <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Želite da šaljete kontakte mobilnom operateru?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Brojevi telefona kontakata se povremeno šalju mobilnom operateru <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Pomoću tih podataka se određuje da li kontakti mogu da koriste određene funkcije, poput video poziva ili nekih funkcija razmene poruka."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Brojevi telefona kontakata se povremeno šalju mobilnom operateru.<xliff:g id="EMPTY_LINE">

</xliff:g>Pomoću tih podataka se određuje da li kontakti mogu da koriste određene funkcije, poput video poziva ili nekih funkcija razmene poruka."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Željeni tip mreže"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (preporučeno)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS poruke"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Šaljite i primajte kada su mobilni podaci isključeni"</string>
    <string name="data_during_calls_title" msgid="3940276893360429144">"Podaci tokom poziva"</string>
    <string name="data_during_calls_summary" msgid="2289050189544214759">"Dozvoli da se ova SIM kartica koristi samo za mobilne podatke tokom poziva"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM kartica za posao"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Pristup aplikacijama i sadržaju"</string>
    <string name="user_rename" msgid="8735940847878484249">"PREIMENUJ"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Podesi ograničenja za aplikaciju"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontroliše <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Ova aplikacija može da pristupa nalozima"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Ova aplikacija može da pristupa vašim nalozima. To kontroliše <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi i mobilni uređaji"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Dozvolite izmenu Wi‑Fi podešavanja i podešavanja za mobilne uređaje"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Dozvolite izmene Bluetooth uparivanja i podešavanja"</string>
    <string name="restriction_nfc_enable_title" msgid="525512312298242911">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="8065688740509581028">"Omogućava razmenu podataka kada ovaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> uređaj dodirne drugi NFC uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="6397567147629410131">"Dozvolite razmenu podataka kada tablet dodirne drugi uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="3331800894734678808">"Dozvolite razmenu podataka kada telefon dodirne drugi uređaj"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Dozvolite da aplikacije koriste informacije o lokaciji"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Nazad"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Dalje"</string>
    <string name="wizard_finish" msgid="4220258401946825946">"Završi"</string>
    <string name="user_image_take_photo" msgid="2601691481533190924">"Slikajte"</string>
    <string name="user_image_choose_photo" msgid="5904586923236027350">"Odaberite sliku"</string>
    <string name="user_image_photo_selector" msgid="7727851029781491727">"Izaberite sliku"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_setup_wizard_title" msgid="3945520353564138219">"SIM kartice"</string>
    <string name="sim_settings_title" msgid="8392862852842113531">"SIM kartice"</string>
    <string name="sim_settings_summary" msgid="5777472623476930332">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7726897488921853655">"SIM kartice su promenjene"</string>
    <string name="sim_cards_changed_message_summary" msgid="7338082681445213621">"Dodirnite da biste podesili aktivnosti"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobilni podaci nisu dostupni"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Dodirnite da biste izabrali SIM karticu za podatke"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Uvek koristi ovo za pozive"</string>
    <string name="select_sim_for_data" msgid="1577092784244587369">"Izaberite SIM karticu za podatke"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Izaberite SIM za SMS-ove"</string>
    <string name="data_switch_started" msgid="6205259094233452188">"Prebacuje se SIM za podatke. To može da potraje do jedan minut..."</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Pozovi pomoću"</string>
    <string name="sim_select_card" msgid="1226182454109919045">"Izbor SIM kartice"</string>
    <string name="sim_card_number_title" msgid="4728780444646439845">"SIM kartica <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_editor_name" msgid="5900178038499314621">"Naziv SIM kartice"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Unesite ime SIM kartice"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Otvor za SIM karticu %1$d"</string>
    <string name="sim_editor_carrier" msgid="2424593350691002557">"Mobilni operater"</string>
    <string name="sim_editor_number" msgid="3209002966895156006">"Broj"</string>
    <string name="sim_editor_color" msgid="9067029630083892961">"Boja SIM kartice"</string>
    <string name="sim_card_select_title" msgid="8146523005929848793">"Izaberite SIM karticu"</string>
    <string name="color_orange" msgid="216547825489739010">"Narandžasta"</string>
    <string name="color_purple" msgid="6603701972079904843">"Ljubičasta"</string>
    <string name="sim_no_inserted_msg" msgid="7272710974813741735">"Nije ubačena nijedna SIM kartica"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Status SIM kartice"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Status SIM kartice (otvor za SIM: %1$d)"</string>
    <string name="sim_call_back_title" msgid="4274099761123657464">"Povratni poziv sa podrazumevane SIM kartice"</string>
    <string name="sim_outgoing_call_title" msgid="7759080345748128897">"SIM kartica za odlazne pozive"</string>
    <string name="sim_other_call_settings" msgid="5956308869284958883">"Druga podešavanja poziva"</string>
    <string name="preferred_network_offload_title" msgid="6453199586512609557">"Željeni mrežni prenos"</string>
    <string name="preferred_network_offload_header" msgid="4842188794016376899">"Onemogući emitov. naziva mreže"</string>
    <string name="preferred_network_offload_footer" msgid="374984523082849648">"Opcija Onemogući emitovanje naziva mreže sprečava treće strane da pristupaju informacijama o mreži."</string>
    <string name="preferred_network_offload_popup" msgid="3949937898807213370">"Onemogućavanjem emitovanja naziva mreže sprečavate automatsko povezivanje sa skrivenim mrežama."</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="584752983048661108">"SIM kartice su promenjene."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Dodirnite da biste podesili"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Pitaj svaki put"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Potrebno je da izaberete nešto"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Izbor SIM kartice"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Podešavanja"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="6585075562837786847">
      <item quantity="one">Prikaži %d skrivenu stavku</item>
      <item quantity="few">Prikaži %d skrivene stavke</item>
      <item quantity="other">Prikaži %d skrivenih stavki</item>
    </plurals>
    <string name="network_dashboard_title" msgid="788543070557731240">"Mreža i internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="4020746665765996480">"mobilna mreža"</string>
    <string name="network_dashboard_summary_data_usage" msgid="2531133412846140766">"potrošnja podataka"</string>
    <string name="network_dashboard_summary_hotspot" msgid="3798394197274240682">"hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Povezani uređaji"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, režim za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, režim za vožnju"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, režim vožnje, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, režim vožnje"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nije dostupno zato što je NFC isključen"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Da biste ovo koristili, prvo instalirajte aplikaciju za plaćanje"</string>
    <string name="app_and_notification_dashboard_title" msgid="2861781687031832943">"Aplikacije i obaveštenja"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedavne aplikacije, podrazumevane aplikacije"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Pristup obaveštenjima nije dostupan za aplikacije na radnom profilu."</string>
    <string name="account_dashboard_title" msgid="2735150283267749852">"Nalozi"</string>
    <string name="account_dashboard_default_summary" msgid="2025250151574540063">"Nijedan nalog nije dodat"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Podrazumevane aplikacije"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Jezici, pokreti, vreme, rezervne kopije"</string>
    <string name="search_results_title" msgid="3360639917793022533">"Podešavanja"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, veza sa mrežom, internet, bežično, podaci, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wi‑Fi obaveštenje, wifi obaveštenje"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"potrošnja podataka"</string>
    <string name="keywords_vibrate_on_touch" msgid="8379369786860641429">"Prekid vibracije, dodir, tastatura"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Koristi 24-časovni format"</string>
    <string name="keywords_storage_files" msgid="4509695858659705198">"Preuzmi"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Otvori pomoću"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikacije"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"vremenska zona"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Oblačić za ćaskanje, sistem, obaveštenje, prozor, dijalog, prikaz, preko drugih aplikacija, prevlačenje"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Baterijska lampa, svetlo, lampa"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, uključi/isključi, kontrola"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilna mreža, mobilni podaci, mobilni operater, bežično, podaci, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"WiFi, Wi-Fi, poziv, pozivanje"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekran, dodirni ekran"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"zatamni ekran, dodirni ekran, baterija, svetlo"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"zatamni ekran, noć, senka, treća smena, osvetljenost, boja ekrana, boja"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"pozadina, personalizovati, prilagoditi ekran"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"veličina teksta"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projekat, prebacivanje, preslikavanje ekrana, deljenje sadržaja ekrana, preslikavanje, deljenje ekrana, prebacivanje sadržaja ekrana"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"prostor, disk, hard disk, korišćenje uređaja"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"potrošnja energije, puniti"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pravopis, rečnik, provera pravopisa, automatsko ispravljanje"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"prepoznavanje, unos, govor, govoriti, jezik, hendsfri, bez ruku, prepoznavanje, uvredljiv, reč, audio, istorija, bluetooth, slušalice"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"brzina, jezik, podrazumevano, govoriti, govor, pretvaranje teksta u govor, pristupačnost, čitač ekrana, slep"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"sat, vojno"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetovati, vratiti, fabrička podešavanja"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"obriši, izbriši, vrati, ukloni, resetuj na fabrička podešavanja"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"štampač"</string>
    <string name="keywords_sounds" msgid="1850691834585575875">"zvučni signal zvučnika, zvučnik, jačina zvuka, isključi zvuk, tišina, zvuk, muzika"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ne ometati, prekidati, prekid, prekinuti"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"u blizini, lokacija, istorija, izveštavanje, GPS"</string>
    <string name="keywords_accounts" msgid="3482052586502133909">"nalog, dodajte nalog, poslovni profil, dodavanje naloga"</string>
    <string name="keywords_users" msgid="3497517660077620843">"ograničenje, ograničiti, ograničeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"ispravka teksta, ispraviti, zvuk, vibrirati, automatski, jezik, pokret, predlagati, predlog, tema, uvredljivo, reč, kucati, emodži, međunarodno"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"resetovanje, podešavanja, podrazumevano"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"preuzimanje, aplikacije, sistem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikacije, dozvole, bezbednost"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikacije, podrazumevano"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorisanje optimizacija, stanje neaktivnosti, aplikacija u mirovanju"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"živopisan, RGB, sRGB, boja, prirodan, standardan"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"boja, temperatura, D65, D73, bela, žuta, plava, topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"prevlačenje za otključavanje, lozinka, šablon, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"kačenje ekrana"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"work izazov, work, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"poslovni profil, profil kojim se upravlja, objedini, objedinjavanje, Work, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"pokreti"</string>
    <string name="keywords_cards_passes" msgid="4798102029412153067">"kreditne kartice, kartice"</string>
    <string name="keywords_device_controls" msgid="8962494082504033651">"kontrole uređaja, kontrole"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"platite, dodirnite, plaćanja"</string>
    <string name="keywords_backup" msgid="707735920706667685">"rezervna kopija, praviti rezervnu kopiju"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"pokret"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"lice, otključavanje, potvrda identiteta, prijavljivanje"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, verzija prl-a, imei sv"</string>
    <string name="keywords_sim_status" msgid="8784456547742075508">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, tip mobilne mreže, roming, iccid, eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serijski broj, verzija hardvera"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nivo bezbednosne zakrpe za android, verzija osnovnog propusnog opsega, verzija jezgra"</string>
    <string name="keywords_dark_ui_mode" msgid="6465231409128452489">"tema, svetla, tamna, režim"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tamna tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"greška"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambijentalni ekran, prikaz na zaključanom ekranu"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"obaveštenje na zaključanom ekranu, obaveštenja"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"lice"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"otisak prsta, dodaj otisak prsta"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"zatamniti ekran, dodirni ekran, baterija, pametna osvetljenost, dinamička osvetljenost, automatska osvetljenost"</string>
    <string name="keywords_display_adaptive_sleep" msgid="8003895686008403685">"zatamnjenje ekrana, spavanje, baterija, gašenje ekrana, pažnja, prikaz, ekran, neaktivnost"</string>
    <string name="keywords_auto_rotate" msgid="7914655570000378975">"rotiraj, obrni, rotacija, uspravno, vodoravno, položaj, vertikalno, horizontalno"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"nadogradnja, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"ne uznemiravaj, raspored, obaveštenja, blokiraj, tišina, vibracija, spavanje, rad, koncentracija, zvuk, isključi zvuk, dan, radni dan, vikend, radni dan uveče, događaj"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"ekran, vreme zaključavanja, gašenje ekrana, zaključan ekran"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memorija, keš, podaci, izbriši, obriši, slobodno, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"povezano, uređaj, slušalice, hedset, zvučnik, bežično, upari, bubice, muzika, mediji"</string>
    <string name="keywords_wallpaper" msgid="6712776876474488023">"pozadina, ekran, zaključani ekran, tema"</string>
    <string name="keywords_styles" msgid="6312134005271042434">"oblik ikone, boja za naglašavanje, font"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"podrazumevano, pomoćnik"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"plaćanje, podrazumevano"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"dolazno obaveštenje"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb privezivanje, bluetooth privezivanje, wi-fi hotspot"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"dodirne povratne informacije, vibracija, ekran, osetljivost"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"dodirne povratne informacije, vibriranje, telefon, poziv, osetljivost, zvono"</string>
    <string name="keywords_notification_vibration" msgid="9162262178415439951">"dodirne povratne informacije, vibriranje, osetljivost"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"ušteda baterije, lepljivo, trajno, ušteda energije, baterija"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, raspored, ušteda baterije, ušteda energije, baterija, automatsko, procenat"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, napredno pozivanje, 4g pozivanje"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"dodaj jezik, dodajte jezik"</string>
    <string name="default_sound" msgid="6604374495015245195">"Podrazumevani zvuk"</string>
    <string name="sound_settings_summary" msgid="944761906531715109">"Jačina zvuka za zvono i obaveštenja je na <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Jačina zvuka, vibracija, Ne uznemiravaj"</string>
    <string name="sound_settings_summary_vibrate" msgid="7192223433295988890">"Zvono je podešeno na vibraciju"</string>
    <string name="sound_settings_summary_silent" msgid="746662794579344761">"Zvono je podešeno na nečujno"</string>
    <string name="sound_settings_example_summary" msgid="8125110691864707925">"Jačina zvuka za zvono i obaveštenja je na 80%"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Jačina zvuka medija"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Jačina zvuka za prebacivanje"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Jačina zvuka poziva"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Jačina zvuka alarma"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Jačina zvuka za zvono i obaveštenja"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Jačina zvuka za obaveštenja"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Zvuk zvona telefona"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Podrazumevani zvuk obaveštenja"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvuk aplikacije"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Podrazumevani zvuk obaveštenja"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Podrazumevani zvuk alarma"</string>
    <string name="vibrate_when_ringing_title" msgid="3436203665622843196">"Vibriraj za pozive"</string>
    <string name="keywords_vibrate_for_calls" msgid="1019870409730074899">"Vibriranje"</string>
    <string name="vibrate_when_ringing_option_never_vibrate" msgid="6518980907289156517">"Nikad ne uključuj vibraciju"</string>
    <string name="vibrate_when_ringing_option_always_vibrate" msgid="968652667232075466">"Uvek vibriraj"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibriraj, pa postepeno zvoni"</string>
    <string name="other_sound_settings" msgid="5468360269346162072">"Drugi zvukovi"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonovi numeričke tastature"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvuk zaključavanja ekrana"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvukovi i vibracija punjenja"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvukovi montiranja"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Zvukovi pri dodiru"</string>
    <string name="vibrate_on_touch_title" msgid="9105544449810547716">"Vibracija pri dodiru"</string>
    <string name="vibrate_on_touch_summary" msgid="664831333409399440">"Dodirne povratne informacije za dodir, tastaturu i još toga"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Reprodukuje bazna stanica"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Svi zvukovi"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Samo medijski zvukovi"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Tišina"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Zvuci"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibracije"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Zvukovi pri uključivanju"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Titl uživo"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatski titl za medije"</string>
    <string name="zen_mode_settings_summary_off" msgid="3604559081434571933">"Ništa"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="1460413335725340350">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> raspored je podešen</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> rasporeda su podešena</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> rasporeda je podešeno</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ne uznemiravaj"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Dobijajte obaveštenja samo od važnih osoba i aplikacija"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Ograničite prekide"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Uključite režim Ne uznemiravaj"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Zvukovi alarma i medija mogu da prekinu"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Rasporedi"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Izbrišite rasporede"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Izbriši"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Izmeni"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Rasporedi"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Raspored"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Raspored"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Utišajte telefon u određeno vreme"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Podesite pravila za režim „Ne uznemiravaj“"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Raspored"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Koristi raspored"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Omogućite prekide koji proizvode zvuk"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokiraj vizuelna ometanja"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Dozvoli vizuelne signale"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opcije prikaza za skrivena obaveštenja"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kada je uključen režim Ne uznemiravaj"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Bez zvučnog signala za obaveštenja"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Videćete obaveštenja na ekranu"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Telefon neće emitovati zvuk ni vibrirati kada stignu obaveštenja."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Bez zvučnog signala ili vizuelnog obaveštenja"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Nećete videti niti čuti obaveštenja"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="4314772315731485747">"U slučaju novih ili postojećih obaveštenja, telefon ih neće prikazivati, niti će vibrirati ili zvoniti. Imajte u vidu da će se važna obaveštenja o aktivnostima i statusu telefona i dalje prikazivati.\n\nKada isključite režim Ne uznemiravaj, propuštena obaveštenja možete da pronađete ako prevučete nadole sa vrha ekrana."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Prilagođeno"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Omogući prilagođeno podešavanje"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Ukloni prilagođeno podešavanje"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Bez zvučnog signala za obaveštenja"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Delimično skriveno"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Bez zvučnog signala ili vizuelnog obaveštenja"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Prilagođena ograničenja"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Isključi zvuk i vibraciju"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Ne uključuj ekran"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ne treperi lampicom"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ne prikazuj iskačuća obaveštenja na ekranu"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Sakrij ikone statusne trake u vrhu"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Sakrij tačke za obaveštenja na ikonama aplikacija"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ne budi zbog obaveštenja"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Sakrij sa kliznog panela"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikad"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Zvuk i vibracija"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Zvuk, vibracija i neki vizuelni znakovi obaveštenja"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvuk, vibracija i vizuelni znakovi obaveštenja"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="1115914818435434668">"Obaveštenja koja su potrebna za osnovne aktivnosti i status telefona nikada neće biti sakrivena."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Ništa"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"druge opcije"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Dodaj"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Uključi"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Uključi"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Isključi"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Režim Ne uznemiravaj je uključen do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Režim Ne uznemiravaj će ostati uključen dok ga ne isključite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Raspored (<xliff:g id="RULE_NAME">%s</xliff:g>) je automatski uključio režim Ne uznemiravaj"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Aplikacija (<xliff:g id="APP_NAME">%s</xliff:g>) je automatski uključila režim Ne uznemiravaj"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Režim Ne uznemiravaj je uključen za <xliff:g id="RULE_NAMES">%s</xliff:g> uz prilagođena podešavanja."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="2310353944697868606"><annotation id="link">" Prikaži prilagođena podešavanja"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Samo prioritetni prekidi"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Uključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2032265904095185048">"Isključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="2102424480808968673">"Isključeno"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Uključeno"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Pitaj svaki put"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Dok ne isključite"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="3601160794696489864">
      <item quantity="one"><xliff:g id="NUM_HOURS">%d</xliff:g> sat</item>
      <item quantity="few"><xliff:g id="NUM_HOURS">%d</xliff:g> sata</item>
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> sati</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="3187122993179039992">"<xliff:g id="NUM_MINUTES">%d</xliff:g> min"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="3812633366476034740">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> raspored može da se uključuje automatski</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> rasporeda mogu da se uključuju automatski</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> rasporeda može da se uključuje automatski</item>
    </plurals>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Šta može da prekine režim Ne uznemiravaj"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Ljudi"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikacije"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmi i drugi prekidi"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Rasporedi"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Trajanje za Brza podešavanja"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Kada je uključen režim Ne uznemiravaj, zvuk i vibracija biće isključeni, osim za stavke koje ste dozvolili iznad."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Prilagođena podešavanja"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Pregledajte raspored"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Važi"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Obaveštenja"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trajanje"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Poruke, događaji i podsetnici"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Kada je uključen režim Ne uznemiravaj, zvukovi obaveštenja za poruke, podsetnike i događaje će biti isključeni, osim za stavke koje ste dozvolili iznad. Možete da prilagodite podešavanja i dozvolite prijateljima, članovima porodice ili drugim kontaktima da dopru do vas."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Gotovo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Podešavanja"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Bez zvučnog signala ili vizuelnog obaveštenja"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Bez zvučnog signala za obaveštenja"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Nećete videti niti čuti obaveštenja. Pozivi od kontakata sa zvezdicom i ponovnih pozivalaca su dozvoljeni."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(trenutno podešavanje)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Želite li da promenite podešavanja obaveštenja za režim Ne uznemiravaj?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvukovi za poslovni profil"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Koristi zvukove ličnog profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="4482832555278975008">"Zvukovi poslovnog profila su isti kao i zvukovi za lične profile"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Melodija zvona poslovnog telefona"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Podrazumevani zvuk obaveštenja za posao"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Podrazumevani zvuk alarma za posao"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Isto kao i za lični profil"</string>
    <string name="work_sync_dialog_title" msgid="2359563902332046231">"Želite li da zamenite zvukove?"</string>
    <string name="work_sync_dialog_yes" msgid="9161415252411868574">"Zameni"</string>
    <string name="work_sync_dialog_message" msgid="1328692374812258546">"Zvukovi sa ličnog profila će se koristiti za poslovni profil"</string>
    <string name="ringtones_install_custom_sound_title" msgid="3885712267015760638">"Dodati prilagođeni zvuk?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="5844996763705884979">"Ova datoteka će biti kopirana u direktorijum <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="26680768777533727">"Melodije zvona"</string>
    <string name="other_sound_category_preference_title" msgid="8182757473602586634">"Drugi zvukovi i vibracije"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Obaveštenja"</string>
    <string name="recent_notifications" msgid="1105631022180160436">"Nedavno poslato"</string>
    <string name="recent_notifications_see_all_title" msgid="3087299996651692987">"Pogledajte sve iz poslednjih 7 dana"</string>
    <string name="advanced_section_header" msgid="6003255455888626056">"Napredna"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Poslovna obaveštenja"</string>
    <string name="smart_notifications_title" msgid="8995288376897952015">"Prilagodljiva obaveštenja"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prioritet prilagodljivog obaveštenja"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Automatski podešava obaveštenja nižeg prioriteta na Diskretno"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Prilagodljivo rangiranje obaveštenja"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automatski rangira obaveštenja prema relevantnosti"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Predložene radnje i odgovori"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automatski prikazuje predložene radnje i odgovore"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Pogledajte nedavna i odložena obaveštenja"</string>
    <string name="notification_history" msgid="8663811361243456201">"Istorija obaveštenja"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Koristi istoriju obaveštenja"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Istorija obaveštenja je isključena"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Uključite istoriju obaveštenja da biste videli nedavna i odložena obaveštenja"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nema nedavnih obaveštenja"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Ovde se prikazuju nedavna i odložena obaveštenja"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"prikaži podešavanja obaveštenja"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"otvaranje obaveštenja"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Omogući odlaganje obaveštenja"</string>
    <string name="hide_silent_icons_title" msgid="5951392023601167577">"Sakrij ikone iz diskretnih obaveštenja"</string>
    <string name="hide_silent_icons_summary" msgid="623763437631637232">"Ikone iz diskretnih obaveštenja se ne prikazuju na statusnoj traci"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Tačka za obaveštenja na ikoni aplikacije"</string>
    <string name="notification_people_strip_title" msgid="1185857822541001139">"Prikaži traku sa nedavnim konverzacijama"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Oblačići"</string>
    <string name="bubbles_feature_education" msgid="4088275802688887634">"Neka obaveštenja i drugi sadržaj mogu da se prikazuju kao oblačići na ekranu. Da biste otvorili oblačić, dodirnite ga. Da biste ga odbacili, prevucite ga nadole na ekranu."</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Oblačići"</string>
    <string name="bubbles_conversation_app_link" msgid="5468779786387915337">"Sva podešavanja oblačića"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Prikaži ovu konverzaciju u oblačiću"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Vidite plutajuću ikonu iznad aplikacija"</string>
    <string name="bubbles_app_toggle_summary" msgid="1574515698567947948">"Dozvolite aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da prikazuje neka obaveštenja kao oblačiće"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Želite da uključite oblačiće za uređaj?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Ako uključite oblačiće za ovu aplikaciju, oni će se uključiti na nivou uređaja.\n\nTo utiče na druge aplikacije ili konverzacije koje podržavaju oblačiće."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Uključi"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Otkaži"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Uključeno/konverzacije mogu da se prikazuju kao plutajuće ikone"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Omogući aplikacijama da prikazuju oblačiće"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Neke konverzacije se prikazuju kao plutajuće ikone preko drugih aplikacija"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Sve konverzacije mogu da se prikazuju u oblačićima"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Izabrane konverzacije mogu da se prikazuju u oblačićima"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Ništa ne može da se prikazuje u oblačićima"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Konverzacije"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Sve konverzacije podržavaju oblačiće osim"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Isključi oblačiće za ovu konverzaciju"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Uključi oblačiće za ovu konverzaciju"</string>
    <string name="swipe_direction_title" msgid="4260320464727178413">"Radnje prevlačenja"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Prevucite udesno da biste odbacili, ulevo da bi se prikazao meni"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Prevucite ulevo da biste odbacili, udesno da bi se prikazao meni"</string>
    <string name="gentle_notifications_title" msgid="2793492905132530991">"Diskretna obaveštenja"</string>
    <string name="gentle_notifications_also_display" msgid="8617545395880297691">"Prikaži i na"</string>
    <string name="gentle_notifications_display_status" msgid="7410244447768694856">"Statusna traka"</string>
    <string name="gentle_notifications_display_lock" msgid="1914245082527924144">"Zaključani ekran"</string>
    <string name="gentle_notifications_education" msgid="5957509621826384362">"Diskretna obaveštenja su uvek nečujna i uvek se prikazuju na kliznom panelu"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="7616926954719310445">"Prikaži samo na kliznom panelu"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="3936088046873705625">"Prikaži na kliznom panelu i zaključanom ekranu"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="3363137853729359907">"Prikaži na kliznom panelu i statusnoj traci"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="2068738866725616212">"Prikaži na kliznom panelu, statusnoj traci i zaključanom ekranu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Sakrij nečujna obaveštenja na statusnoj traci"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Uključi treperenje lampice"</string>
    <string name="lock_screen_notifications_title" msgid="3063951257121435570">"Obaveštenja na zaključanom ekranu"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Preskoči zaključan ekran"</string>
    <string name="lockscreen_bypass_summary" msgid="6688592486830491144">"Posle otključavanja licem idi direktno na poslednji ekran"</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"zaključani ekran, preskočiti, zaobići"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kada je poslovni profil zaključan"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Obaveštenja na zaključanom ekranu"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Prikazuj konverzacije, uključujući podrazumevane i nečujne"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Sakrij tihe konverzacije i obaveštenja"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ne prikazuj nikakva obaveštenja"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Osetljiva obaveštenja"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Prikazuj osetljiv sadržaj na zaključanom ekranu"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Osetljiva obaveštenja o poslovnom profilu"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Prikazuj osetljiv sadržaj poslovnog profila na zaključanom ekranu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Prikaži sav sadržaj obaveštenja"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Prikaži osetljiv sadržaj samo kada je otključano"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Ne prikazuj nikakva obaveštenja"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Kako želite da se prikazuje sadržaj na zaključanom ekranu?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Zaključan ekran"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Prikazuj sav sadržaj obaveštenja o poslovnom profilu"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Sakrij osetljiv sadržaj poslovnog profila"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kada je uređaj zaključan, kako želite da se prikazuju obaveštenja o profilu?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Obaveštenja o profilu"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Obaveštenja"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Obaveštenja aplikacija"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategorija obaveštenja"</string>
    <string name="notification_group_title" msgid="7525666535695631538">"Grupa kategorija obaveštenja"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Ponašanje"</string>
    <string name="notification_importance_unspecified" msgid="1543165530748339700">"Dozvoli zvuk"</string>
    <string name="notification_importance_blocked" msgid="4933285639639899394">"Nikada ne prikazuj obaveštenja"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Konverzacije"</string>
    <string name="conversation_category_title" msgid="6777135786004214149">"Konverzacija"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Odeljak za konverzacije"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Dozvoljava da aplikacija koristi odeljak za konverzacije"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nije konverzacija"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Uklonite iz odeljka konverzacija"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Ovo je konverzacija"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Dodajte u odeljak konverzacija"</string>
    <string name="manage_conversations" msgid="4440289604887824337">"Upravljajte konverzacijama"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nema prioritetnih konverzacija"</string>
    <plurals name="priority_conversation_count" formatted="false" msgid="4229447176780862649">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> prioritetna konverzacija</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> prioritetne konverzacije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> prioritetnih konverzacija</item>
    </plurals>
    <string name="important_conversations" msgid="1233893707189659401">"Prioritetne konverzacije"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Prikazuju se u vrhu odeljka za konverzacije i u obliku oblačića"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Prikazuju se u vrhu odeljka za konverzacije"</string>
    <string name="other_conversations" msgid="7218658664423361043">"Ostale konverzacije"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Konverzacije koje ste menjali"</string>
    <string name="important_bubble" msgid="7911698275408390846">"Prikaži prioritetne konverzacije u oblačićima"</string>
    <string name="important_conversation_behavior_summary" msgid="1845064084071107732">"Prioritetne konverzacije se prikazuju u vrhu kliznog panela. Možete i da ih podesite tako da imaju oblačiće i da prekidaju režim Ne uznemiravaj."</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prioritetne i izmenjene konverzacije se prikazuju ovde"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Kada označite konverzaciju kao prioritetnu ili obavite druge promene u konverzacijama, prikazivaće se ovde. \n\nDa biste promenili podešavanja konverzacija: \nPrevucite nadole od vrha ekrana da biste otvorili klizni panel, pa dodirnite i zadržite konverzaciju."</string>
    <string name="notification_importance_min" msgid="4609688642942787774">"Prikazuj bez zvučnog signala i umanji"</string>
    <string name="notification_importance_low" msgid="7562535765919565273">"Prikazuje se bez zvučnog signala"</string>
    <string name="notification_importance_default" msgid="7483906490369073043">"Emituje se zvučni signal"</string>
    <string name="notification_importance_high" msgid="8453789143477210550">"Emituje se zvučni signal i prikazuje se na ekranu"</string>
    <string name="notification_importance_high_silent" msgid="8977232884004607985">"Iskačuće obaveštenje na ekranu"</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Umanji"</string>
    <string name="notification_importance_low_title" msgid="658158049378796947">"Srednji"</string>
    <string name="notification_importance_default_title" msgid="8875198696330289686">"Visok"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Iskačuće obaveštenje na ekranu"</string>
    <string name="notification_block_title" msgid="7392909527700971673">"Blokiraj"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Nečujno"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Podrazumevano"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Dozvoli prekide"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Dozvolite aplikaciji da aktivira zvuk, vibraciju i/ili da prikazuje iskačuća obaveštenja na ekranu"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritet"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Prikazuje se u vrhu odeljka za konverzacije kao plutajući oblačić, prikazuje sliku profila na zaključanom ekranu"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> ne podržava većinu funkcija konverzacije. Ne možete da podesite konverzaciju kao prioritetnu i konverzacije se ne prikazuju kao plutajući oblačići."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Na kliznom panelu skupite obaveštenja u jedan red"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Bez zvuka i vibriranja"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Bez zvuka i vibriranja i prikazuje se u nastavku odeljka za konverzacije"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Može da zvoni ili vibrira u zavisnosti od podešavanja telefona"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kada je uređaj otključan, prikazuje obaveštenja kao baner u vrhu ekrana"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Sva obaveštenja aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Sva obaveštenja aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="default_notification_assistant" msgid="243718059890346442">"Prilagodljiva obaveštenja"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="1479283620504341566">
      <item quantity="one">~<xliff:g id="NUMBER_1">%d</xliff:g> obaveštenje dnevno</item>
      <item quantity="few">~<xliff:g id="NUMBER_1">%d</xliff:g> obaveštenja dnevno</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> obaveštenja dnevno</item>
    </plurals>
    <plurals name="notifications_sent_weekly" formatted="false" msgid="4913443431857170519">
      <item quantity="one">~<xliff:g id="NUMBER_1">%d</xliff:g> obaveštenje nedeljno</item>
      <item quantity="few">~<xliff:g id="NUMBER_1">%d</xliff:g> obaveštenja nedeljno</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> obaveštenja nedeljno</item>
    </plurals>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikad"</string>
    <string name="manage_notification_access_title" msgid="4714320299084782521">"Pristup obaveštenjima"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Pristup obaveštenjima poslovnog profila je blokiran"</string>
    <string name="manage_notification_access_summary_zero" msgid="7528633634628627431">"Aplikacije ne mogu da čitaju obaveštenja"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="3703008881487586312">
      <item quantity="one">%d aplikacija može da čita obaveštenja</item>
      <item quantity="few">%d aplikacije mogu da čitaju obaveštenja</item>
      <item quantity="other">%d aplikacija može da čita obaveštenja</item>
    </plurals>
    <string name="notification_assistant_title" msgid="6983941403582134437">"Prilagodljiva obaveštenja"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Nema"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Nijedna instalirana aplikacija nije zahtevala pristup obaveštenjima."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Dozvoli pristup obaveštenjima"</string>
    <string name="notification_assistant_security_warning_title" msgid="2972346436050925276">"Želite li da dozvolite da <xliff:g id="SERVICE">%1$s</xliff:g> ima pristup obaveštenjima?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="7362924206925040510">"<xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> će moći da čita sva obaveštenja, uključujući lične podatke, poput imena kontakata i teksta poruka koje primate. Ova aplikacija će moći i da odbacuje obaveštenja ili aktivira dugmad u obaveštenjeima, uključujući javljanje na telefonske pozive. \n\nOvo će aplikaciji omogućiti i da uključuje ili isključuje režim Ne uznemiravaj i menja srodna podešavanja."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Želite li da omogućite pristup obaveštenjima za <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1658213659262173405">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> će moći da čita sva obaveštenja, uključujući lične podatke, poput imena kontakata i teksta poruka koje primate. Ova aplikacija će moći i da odbacuje obaveštenja ili aktivira dugmad u obaveštenjeima, uključujući javljanje na telefonske pozive. \n\nOvo će aplikaciji omogućiti i da uključuje ili isključuje režim Ne uznemiravaj i menja srodna podešavanja."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Ako isključite pristup obaveštenjima za korisnika <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, isključićete i pristup režimu Ne uznemiravaj."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Isključi"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Otkaži"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Usluge pomagača za virtuelnu realnost"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nijedna instalirana aplikacija nije zahtevala da se pokrene kao usluga pomagača za virtuelnu realnost."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Želite li da dozvolite pristup usluzi virtuelne realnosti za <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> će moći da se pokrene kada koristite aplikacije u režimu virtuelne realnosti."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Kada je uređaj u režimu za virtuelnu realnost"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Smanji zamagljivanje (preporučeno)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Smanji treperenje"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Slika u slici"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Nijedna instalirana aplikacija ne podržava sliku u slici"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"sus slika u"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Slika u slici"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Dozvoli sliku u slici"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Dozvolite ovoj aplikaciji da pravi prozor slike u slici dok je otvorena ili kada izađete iz nje (na primer, da biste nastavili da gledate neki video). Ovaj prozor se prikazuje preko drugih aplikacija koje koristite."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Povezane poslovne i lične aplikacije"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Povezano je"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nije povezano"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nema povezanih aplikacija"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"više vrsta profila povezana aplikacija aplikacije posao i lično"</string>
    <string name="interact_across_profiles_app_detail_title" msgid="7776184211173575648">"Povezane poslovne i lične aplikacije"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Povezano"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Poveži ove aplikacije"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Povezane aplikacije dele dozvole i mogu da pristupaju podacima međusobno."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Povežite aplikacije samo ako verujete da ne dele lične podatke sa IT administratorom."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Uvek možete da opozovete povezivanje aplikacija u podešavanjima privatnosti na uređaju."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Želite li da poverite lične podatke aplikaciji <xliff:g id="NAME">%1$s</xliff:g> za posao?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Povežite aplikacije samo ako verujete da ne dele lične podatke sa IT administratorom."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Podaci aplikacija"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Ova aplikacija može da pristupa podacima u ličnoj aplikaciji <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Dozvole"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Ova aplikacija može da koristi dozvole lične aplikacije <xliff:g id="NAME">%1$s</xliff:g>, poput pristupa lokaciji, memorijskom prostoru ili kontaktima."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nema povezanih aplikacija"</string>
    <plurals name="interact_across_profiles_number_of_connected_apps" formatted="false" msgid="6991750455661974772">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija je povezana</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aplikacije su povezane</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija je povezano</item>
    </plurals>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Da biste povezali ove aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na poslovnom profilu"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Da biste povezali ove aplikacije, instalirajte aplikaciju <xliff:g id="NAME">%1$s</xliff:g> na ličnom profilu"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Dodirnite da biste preuzeli aplikaciju"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Pristup opciji Ne uznemiravaj"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Dozvoli režim Ne uznemiravaj"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nijedna instalirana aplikacija nije zahtevala pristup opciji Ne uznemiravaj"</string>
    <string name="loading_notification_apps" msgid="1458413761470945269">"Učitavaju se aplikacije..."</string>
    <string name="app_notifications_off_desc" msgid="6691342160980435901">"Na vaš zahtev, Android blokira prikazivanje obaveštenja ove aplikacije na ovom uređaju"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Na vaš zahtev, Android blokira prikazivanje ove kategorije obaveštenja na ovom uređaju"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Na vaš zahtev, Android blokira prikazivanje ove grupe obaveštenja na ovom uređaju"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorije"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Drugo"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="483490958130993160">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
    </plurals>
    <string name="no_channels" msgid="4716199078612071915">"Ova aplikacija nije postavila nijedno obaveštenje"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Dodatna podešavanja u aplikaciji"</string>
    <string name="notification_screen_summary" msgid="5984915275134654822">"Istorija obaveštenja, oblačići, nedavno poslato"</string>
    <string name="app_notification_listing_summary_zero" msgid="2988400013221120744">"Uključeno za sve aplikacije"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="1506127395400503717">
      <item quantity="one">Isključeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikaciju</item>
      <item quantity="few">Isključeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other">Isključeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="5963473421547029532">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija je izbrisana</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije su izbrisane</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorija je izbrisano</item>
    </plurals>
    <string name="notification_toggle_on" msgid="1624283327379059003">"Uključeno"</string>
    <string name="notification_toggle_off" msgid="3295373308338024844">"Isključeno"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokiraj sve"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Nikada ne prikazuj ova obaveštenja"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Prikazuj obaveštenja"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Obaveštenja se nikada ne prikazuju na traci ili periferijskim uređajima"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Dozvoli tačku za obaveštenja"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Prikazuj tačku za obaveštenja"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Zameni režim Ne uznemiravaj"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Omogućite da ova obaveštenja nastave da se prikazuju kada je režim Ne uznemiravaj uključen"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Zaključan ekran"</string>
    <string name="app_notification_row_banned" msgid="4513523107019706924">"Blokirano"</string>
    <string name="app_notification_row_priority" msgid="8100777138078316446">"Prioritet"</string>
    <string name="app_notification_row_sensitive" msgid="7374688948587174964">"Osetljivo"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Gotovo"</string>
    <string name="app_notification_importance_title" msgid="8293193440040799998">"Važnost"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Uključi treperenje lampice"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibriranje"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Zvuk"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritet"</string>
    <string name="notification_conversation_add_to_home" msgid="8136269431130231389">"Dodajte u dom"</string>
    <string name="zen_mode_rule_delete_button" msgid="7642063606919058862">"Izbriši"</string>
    <string name="zen_mode_rule_rename_button" msgid="4158377587795511144">"Preimenuj"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Naziv rasporeda"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Unesite naziv rasporeda"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Naziv rasporeda se već koristi"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Dodaj još"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Dodajte raspored događaja"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Dodajte vremenski raspored"</string>
    <string name="zen_mode_delete_rule" msgid="5419296431989891130">"Izbriši raspored"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Odaberite tip rasporeda"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Želite da izbrišete pravilo „<xliff:g id="RULE">%1$s</xliff:g>“?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Izbriši"</string>
    <string name="zen_mode_rule_type_unknown" msgid="7819162569994282316">"Nepoznato"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Ova podešavanja trenutno ne mogu da se menjaju. Aplikacija (<xliff:g id="APP_NAME">%1$s</xliff:g>) je automatski uključila režim Ne uznemiravaj sa prilagođenim ponašanjem."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Ova podešavanja trenutno ne mogu da se menjaju. Aplikacija je automatski uključila režim Ne uznemiravaj sa prilagođenim ponašanjem."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Ova podešavanja trenutno ne mogu da se menjaju. Režim Ne uznemiravaj sa prilagođenim ponašanjem je uključen ručno."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Vreme"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="6534402316741678208">"Automatsko pravilo je podešeno da se podešavanje Ne uznemiravaj uključuje tokom navedenih perioda"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Događaj"</string>
    <string name="zen_event_rule_enabled_toast" msgid="4943723266121388395">"Automatsko pravilo je podešeno da se podešavanje Ne uznemiravaj uključuje tokom navedenih događaja"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Tokom događaja za"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="3065013489987409864">"Tokom događaja za <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="8395450413356855311">"bilo koji kalendar"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="7786137431469077008">"Gde je odgovor <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Bilo koji kalendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Gde je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Da, Možda ili Nema odgovora"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Da ili Možda"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Da"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Pravilo nije pronađeno."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Uključeno/<xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Dani"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Nijedan"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="1583884351893245169">"Svakog dana"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarm može da zameni vreme završetka"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Raspored se isključuje kada alarm zazvoni"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Ponašanje režima Ne uznemiravaj"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Koristi podrazumevana podešavanja"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Napravite prilagođena podešavanja za ovaj raspored"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Za „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g>–<xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="6022314482293187463">"Od <xliff:g id="START">%1$s</xliff:g> do <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Konverzacije"</string>
    <string name="zen_mode_conversations_section_title" msgid="666809483050936026">"Konverzacije koje mogu da prekidaju"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Sve konverzacije"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioritetne konverzacije"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Ništa"</string>
    <plurals name="zen_mode_conversations_count" formatted="false" msgid="8348944826762075457">
      <item quantity="one"><xliff:g id="CONVERSATIONS">%d</xliff:g> konverzacija</item>
      <item quantity="few"><xliff:g id="CONVERSATIONS">%d</xliff:g> konverzacije</item>
      <item quantity="other"><xliff:g id="CONVERSATIONS">%d</xliff:g> konverzacija</item>
    </plurals>
    <string name="zen_mode_conversations_count_none" msgid="4745022470794983983">"Ništa"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Ko može da prekida"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Pozivi"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Pozivi"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"pozivi"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Pozivi koji mogu da prekidaju"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Da biste bili sigurni da će se dozvoljeni pozivi čuti, proverite da li je uređaj podešen da zvoni"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Dolazni pozivi su blokirani za „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“. Možete da prilagodite podešavanja i dozvolite prijateljima, članovima porodice ili drugim kontaktima da dopru do vas."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontakti sa zvezdicom"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="7001724653833724925">
      <item quantity="one">Još <xliff:g id="NUM_PEOPLE">%d</xliff:g> osoba</item>
      <item quantity="few">Još <xliff:g id="NUM_PEOPLE">%d</xliff:g> osobe</item>
      <item quantity="other">Još <xliff:g id="NUM_PEOPLE">%d</xliff:g> osoba</item>
    </plurals>
    <string name="zen_mode_starred_contacts_summary_none" msgid="6320777044373994482">"Ništa"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Poruke"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"poruke"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Poruke"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Poruke koje mogu da prekidaju"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Da biste bili sigurni da će se dozvoljene poruke čuti, proverite da li je uređaj podešen da zvoni"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Dolazne poruke su blokirane za „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“. Možete da prilagodite podešavanja i dozvolite prijateljima, članovima porodice ili drugim kontaktima da dopru do vas."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Dostupni ste za sve poruke"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Dostupni ste za sve pozive"</string>
    <string name="zen_mode_contacts_count_none" msgid="7928563147160462589">"Ništa"</string>
    <plurals name="zen_mode_contacts_count" formatted="false" msgid="3434092344686708445">
      <item quantity="one"><xliff:g id="NUM_CONTACTS">%d</xliff:g> kontakt</item>
      <item quantity="few"><xliff:g id="NUM_CONTACTS">%d</xliff:g> kontakta</item>
      <item quantity="other"><xliff:g id="NUM_CONTACTS">%d</xliff:g> kontakata</item>
    </plurals>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Svi"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakti"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontakti sa zvezdicom"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="8078759939219244001">"Od kontakata sa zvezdicom i ponovnih pozivalaca"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="2276432091940405376">"Od kontakata i ponovnih pozivalaca"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7748352153193832632">"Samo od ponovnih pozivalaca"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Ništa"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Ništa"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmi"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Obaveštenja tajmera, alarma, bezbednosnih sistema i drugih aplikacija"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmi"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmi"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Zvukovi medija"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Zvuci iz video snimaka, igara i drugih medija"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"mediji"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Mediji"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Zvukovi pri dodiru"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvuci tastature i druge dugmadi"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvukovi pri dodiru"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Zvukovi pri dodiru"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Podsetnici"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Obaveštenja o zadacima i podsetnicima"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"podsetnici"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Podsetnici"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Događaji iz kalendara"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Obaveštenja o predstojećim događajima iz kalendara"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"događaji"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Događaji"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Dozvoli da aplikacije zanemaruju"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikacije koje mogu da prekidaju"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Izaberite još aplikacija"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nema izabranih aplikacija"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nijedna aplikacija ne može da prekine"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Dodaj aplikacije"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Sva obaveštenja"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Neka obaveštenja"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Izabrani ljudi i dalje dopiru do vas čak i ako ne omogućite aplikacijama da vas prekidaju"</string>
    <plurals name="zen_mode_bypassing_apps_subtext" formatted="false" msgid="7781990918323204156">
      <item quantity="one"><xliff:g id="APP_NAMES">%s</xliff:g> mogu da prekinu</item>
      <item quantity="few"><xliff:g id="APP_NAMES">%s</xliff:g> mogu da prekinu</item>
      <item quantity="other"><xliff:g id="APP_NAMES">%s</xliff:g> mogu da prekinu</item>
    </plurals>
    <string name="zen_mode_apps_bypassing_list_count" msgid="1581384924379825405">"Još <xliff:g id="NUMBER">%d</xliff:g>"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikacije"</string>
    <string name="zen_mode_bypassing_apps_all_summary" msgid="5197566190120503132">"Sva obaveštenja"</string>
    <string name="zen_mode_bypassing_apps_some_summary" msgid="1514572070650411509">"Neka obaveštenja"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Obaveštenja koja mogu da prekidaju"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Omogući sva obaveštenja"</string>
    <plurals name="zen_mode_other_sounds_summary" formatted="false" msgid="945147615383565311">
      <item quantity="one"><xliff:g id="SOUND_CATEGORIES">%s</xliff:g> mogu da prekinu</item>
      <item quantity="few"><xliff:g id="SOUND_CATEGORIES">%s</xliff:g> mogu da prekinu</item>
      <item quantity="other"><xliff:g id="SOUND_CATEGORIES">%s</xliff:g> mogu da prekinu</item>
    </plurals>
    <string name="zen_mode_other_sounds_none" msgid="6219663385759635854">"Ništa ne može da prekine"</string>
    <string name="zen_mode_other_sounds_list_count" msgid="1443126333853419582">"Još <xliff:g id="NUMBER">%d</xliff:g>"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Niko ne može da prekine"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Neki ljudi mogu da prekinu"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Svi ljudi mogu da prekinu"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Ponovni pozivaoci"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Dozvoli ponovne pozivaoce"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"svi"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontakti"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontakti sa zvezdicom"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"ponovni pozivaoci"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> i <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Ako ista osoba pozove po drugi put u periodu od <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="3126805555852783860">"Prilagođeno"</string>
    <string name="zen_mode_when" msgid="5710214762051824755">"Automatski uključi"</string>
    <string name="zen_mode_when_never" msgid="2537537280091840672">"Nikad"</string>
    <string name="zen_mode_when_every_night" msgid="9018738747936038166">"Svake večeri"</string>
    <string name="zen_mode_when_weeknights" msgid="531342225633264368">"Radnim danima uveče"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Vreme početka"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Vreme završetka"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"U <xliff:g id="FORMATTED_TIME">%s</xliff:g> sledećeg dana"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Prebacuje u režim samo sa alarmima na neodređeno vreme"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="1900512966361163390">
      <item quantity="one">Prebacuje u režim samo sa alarmima u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> minuta (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">Prebacuje u režim samo sa alarmima u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> minuta (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Prebacuje u režim samo sa alarmima u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> minuta (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="955991428001659124">
      <item quantity="one">Prebacuje u režim samo sa alarmima u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> sata do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="few">Prebacuje u režim samo sa alarmima u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> sata do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Prebacuje u režim samo sa alarmima u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> sati do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Prebacuje u režim samo sa alarmima do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Prebacuje u režim uvek prekidaj"</string>
    <string name="zen_mode_screen_on" msgid="7312758100468915319">"Kada je ekran uključen"</string>
    <string name="zen_mode_screen_on_summary" msgid="510055058460316698">"Neka obaveštenja isključena režimom Ne uznemiravaj iskaču na ekranu i prikažu ikonu na statusnoj traci"</string>
    <string name="zen_mode_screen_off" msgid="7069798697669366075">"Kada je ekran isključen"</string>
    <string name="zen_mode_screen_off_summary" msgid="4698018253505406152">"Neka obaveštenja koja su isključena režimom Ne uznemiravaj uključe ekran i aktiviraju svetlosni signal"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="1958271859408992636">"Neka obaveštenja koja su isključena režimom Ne uznemiravaj uključe ekran"</string>
    <string name="notification_app_settings_button" msgid="4692549882609342128">"Podešavanja obaveštenja"</string>
    <string name="suggestion_button_text" msgid="4370673818678692873">"Potvrdi"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Zatvori"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Šalji povratne informacije o uređaju"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Unesite PIN administratora"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Uključeno"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Isključeno"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Kačenje aplikacija"</string>
    <string name="screen_pinning_description" msgid="6927147836599784578">"Kačenje aplikacija vam omogućava da zadržite prikaz aplikacije dok je ne otkačite. Pomoću ove funkcije možete, na primer, da dozvolite pouzdanom prijatelju da igra određenu igru. \n\nKada je aplikacija zakačena, može da otvara druge aplikacije i lični podaci mogu da budu dostupni. \n\nDa biste koristili kačenje aplikacija: 	\n1.	Uključite kačenje aplikacija 	\n2.	Otvorite Pregled 	\n3.	Dodirnite ikonu aplikacije u vrhu ekrana, pa dodirnite Zakači"</string>
    <string name="screen_pinning_guest_user_description" msgid="4772752097527490014">"Kačenje aplikacija vam omogućava da zadržite prikaz aktuelne aplikacije dok je ne otkačite. Pomoću ove funkcije možete, na primer, da dozvolite pouzdanom prijatelju da igra određenu igru. \n\nKada je aplikacija zakačena, može da otvara druge aplikacije i lični podaci mogu da budu dostupni. \n\nAko želite da bezbedno delite uređaj sa nekim, bolje koristite profil gosta. \n\nDa biste koristili kačenje aplikacija: 	\n1.	Uključite kačenje aplikacija 	\n2.	Otvorite Pregled 	\n3.	Dodirnite ikonu aplikacije u vrhu ekrana, pa dodirnite Zakači"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kada je aplikacija zakačena: \n\n•	 Mogu da budu dostupni lični podaci \n		(na primer, kontakti i sadržaj imejlova) \n•	 Zakačena aplikacija može da otvara druge aplikacije \n\nKoristite kačenje aplikacija samo sa ljudima kojima verujete."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Traži šablon za otključavanje pre otkačinjanja"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Traži PIN pre otkačinjanja"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Traži lozinku pre otkačinjanja"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Zaključaj uređaj pre otkačinjanja"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Potvrdite brisanje SIM kartice"</string>
    <string name="confirm_sim_deletion_description" msgid="8937609409607338516">"Potvrdite da ste to vi pre nego što obrišete preuzetu SIM karticu"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Ovim poslovnim profilom upravlja:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Upravlja <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="869354050717870055">"(Eksperimentalno)"</string>
    <string name="encryption_interstitial_header" msgid="4418014339568737685">"Bezbedno pokretanje"</string>
    <string name="encryption_continue_button" msgid="3591796237625134622">"Nastavi"</string>
    <string name="encryption_interstitial_message_pin" msgid="1413575143234269985">"Možete dodatno da zaštitite ovaj uređaj tako što ćete ga podesiti da traži PIN pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme. \n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Želite zahtev za PIN pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="726550613252236854">"Možete dodatno da zaštitite ovaj uređaj tako što ćete ga podesiti da traži šablon pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme. \n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Zahtevati šablon pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_password" msgid="6051054565294909975">"Možete dodatno da zaštitite uređaj tako što ćete ga podesiti da traži lozinku pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke ili obaveštenja, uključujući alarme. \n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Zahtevati lozinku pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="7152770518093102916">"Pored toga što možete da otključavate uređaj otiskom prsta, možete dodatno da ga zaštitite tako što ćete ga podesiti da traži PIN pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme.\n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Želite zahtev za PIN pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="6257856552043740490">"Pored toga što možete da otključavate uređaj otiskom prsta, možete dodatno da ga zaštitite tako što ćete ga podesiti da traži šablon pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme.\n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Želite li zahtev šablona pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="7710804822643612867">"Pored toga što možete da otključavate uređaj otiskom prsta, možete dodatno da ga zaštitite tako što ćete ga podesiti da traži lozinke pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme.\n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Zahtevati lozinku pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="8577135499926738241">"Pored toga što možete da otključavate uređaj pomoću lica, možete dodatno da ga zaštitite tako što ćete ga podesiti da traži PIN pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme.\n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Želite li da se zahteva unos PIN-a pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="5851725964283239644">"Pored toga što možete da otključavate uređaj pomoću lica, možete dodatno da ga zaštitite tako što ćete ga podesiti da traži šablon pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme.\n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Želite li da se zahteva unos šablona pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3553329272456428461">"Pored toga što možete da otključavate uređaj pomoću lica, možete dodatno da ga zaštitite tako što ćete ga podesiti da traži lozinke pre pokretanja. Dok se uređaj ne pokrene, ne može da prima pozive, poruke niti obaveštenja, uključujući alarme.\n\nTo omogućava zaštitu podataka na izgubljenim ili ukradenim uređajima. Želite li da se zahteva unos lozinke pri pokretanju uređaja?"</string>
    <string name="encryption_interstitial_yes" msgid="1948016725089728181">"Da"</string>
    <string name="encryption_interstitial_no" msgid="3352331535473118487">"Ne"</string>
    <string name="restricted_true_label" msgid="612852292488747564">"Ograničeno"</string>
    <string name="restricted_false_label" msgid="2837053797913490628">"Aplikacija može da troši bateriju u pozadini"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8974156384205924887">"Tražiti PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1587587568721873184">"Tražiti šablon?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="2701793623210531836">"Tražiti lozinku?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="4482887117824444481">"Kada unesete PIN da biste pokrenuli ovaj uređaj, usluge pristupačnosti, kao što je <xliff:g id="SERVICE">%1$s</xliff:g>, neće još uvek biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="5156321541636018756">"Kada unesete šablon da biste pokrenuli ovaj uređaj, usluge pristupačnosti, kao što je <xliff:g id="SERVICE">%1$s</xliff:g>, neće još uvek biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="1917287751192953034">"Kada unesete lozinku da biste pokrenuli ovaj uređaj, usluge pristupačnosti, kao što je <xliff:g id="SERVICE">%1$s</xliff:g>, neće još uvek biti dostupne."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="5766006106305996844">"Napomena: Ako restartujete telefon i podesili ste zaključavanje ekrana, ova aplikacija ne može da se pokrene dok ne otključate telefon"</string>
    <string name="imei_information_title" msgid="8703564992893669514">"Informacije za IMEI"</string>
    <string name="imei_information_summary" msgid="4763358372990258786">"Relativne informacije za IMEI"</string>
    <string name="slot_number" msgid="2663789411468530397">"(Otvor <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Podrazumevano otvaraj"</string>
    <string name="app_launch_domain_links_title" msgid="6702041169676128550">"Otvaranje linkova"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Otvaraj podržane linkove"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="3609156836041234957">"Otvaraj bez pitanja"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podržani linkovi"</string>
    <string name="app_launch_other_defaults_title" msgid="3296350563585863885">"Druge podrazumevane aplikacije"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"Koristi se <xliff:g id="SIZE">%1$s</xliff:g> u: <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"interna memorija"</string>
    <string name="storage_type_external" msgid="125078274000280821">"spoljna memorija"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> se koristi od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Memorijski prostor u upotrebi"</string>
    <string name="change" msgid="273206077375322595">"Promeni"</string>
    <string name="change_storage" msgid="8773820275624113401">"Promenite memoriju"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Obaveštenja"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Uključena"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g> / <xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Isključeno"</string>
    <string name="notifications_partly_blocked" msgid="5738239705473445725">"Uključenih kategorija: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="notifications_silenced" msgid="2673798575466545098">"Isključena"</string>
    <string name="notifications_redacted" msgid="8820993927920208612">"Nema osetljivog sadržaja na zaključanom ekranu"</string>
    <string name="notifications_hidden" msgid="2415415452913806859">"Ne na zaključanom ekranu"</string>
    <string name="notifications_priority" msgid="9068574646650663837">"Režim Ne uznemiravaj je zamenjen"</string>
    <string name="notifications_summary_divider" msgid="6877149909390030983">" / "</string>
    <string name="notification_summary_level" msgid="4074326972839105652">"%d. nivo"</string>
    <string name="notification_summary_channel" msgid="8459033623057872803">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="1385401442703692986">
      <item quantity="one">Isključena je <xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
      <item quantity="few">Isključene su <xliff:g id="COUNT_1">%d</xliff:g> kategorije</item>
      <item quantity="other">Isključeno je <xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="5015472550875144481">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dozvola je odobrena</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dozvole su odobrene</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dozvola je odobreno</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="2091022049141391855">
      <item quantity="one">Data je <xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> dozvola</item>
      <item quantity="few">Date su <xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> dozvola</item>
      <item quantity="other">Dato je <xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> dozvola</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="5888624648943937645">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dodatna dozvola</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dodatne dozvole</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dodatnih dozvola</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nijedna dozvola nije odobrena"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nijedna dozvola nije zahtevana"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Kontroliše pristup aplikacija podacima"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Sve aplikacije"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Instalirane aplikacije"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Instant aplikacije"</string>
    <string name="filter_notif_all_apps" msgid="2764590815789208306">"Aplikacije: sve"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Isključeno"</string>
    <string name="filter_notif_urgent_channels" msgid="875381675739324318">"Kategorije: visok prioritet"</string>
    <string name="filter_notif_low_channels" msgid="2163005243095264537">"Kategorije: nizak prioritet"</string>
    <string name="filter_notif_blocked_channels" msgid="1131444963543380495">"Kategorije: isključeno"</string>
    <string name="filter_notif_dnd_channels" msgid="13445325087914932">"Kategorije: menja režim „Ne uznemiravaj“"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Napredno"</string>
    <string name="configure_apps" msgid="5468359087126598115">"Konfigurišite aplikacije"</string>
    <string name="unknown_app" msgid="2027248925719898714">"Nepoznata aplikacija"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Menadžer dozvola"</string>
    <string name="app_permissions_summary" msgid="2709819220672938860">"Aplikacije u kojima se koristi <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="app_permissions_summary_more" msgid="6247952473615352350">"Aplikacije koje koriste dozvolu <xliff:g id="APPS">%1$s</xliff:g> i drugo"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Dodirnite za buđenje"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dvaput dodirnite bilo koji deo ekrana da biste probudili uređaj"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Otvaranje linkova"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ne otvaraj podržane linkove"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Otvaraj <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Otvaraj <xliff:g id="DOMAIN">%s</xliff:g> i druge URL-ove"</string>
    <string name="domain_urls_apps_summary_off" msgid="2534980824850890416">"Nijedna aplikacija ne otvara podržane linkove"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="7864816862441985323">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija otvara podržane linkove</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije otvaraju podržane linkove</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija otvara podržane linkove</item>
    </plurals>
    <string name="app_link_open_always" msgid="9167065494930657503">"Dozvoli aplikaciji da otvara podržane linkove"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Pitaj svaki put"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Ne dozvoli aplikaciji da otvara linkove"</string>
    <plurals name="app_link_open_always_summary" formatted="false" msgid="1816161439007251694">
      <item quantity="one">Aplikacija tvrdi da obrađuje <xliff:g id="COUNT_1">%d</xliff:g> link</item>
      <item quantity="few">Aplikacija tvrdi da obrađuje <xliff:g id="COUNT_1">%d</xliff:g> linka</item>
      <item quantity="other">Aplikacija tvrdi da obrađuje <xliff:g id="COUNT_1">%d</xliff:g> linkova</item>
    </plurals>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikacija tvrdi da obrađuje sledeće linkove:"</string>
    <string name="default_apps_title" msgid="6943471331817718664">"Podrazumevana"</string>
    <string name="default_for_work" msgid="537558180548617528">"Podrazumevana za posao"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Pomoć i glasovni unos"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Aplikacija digitalnog pomoćnika"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Podrazumev. digitalni pomoćnik"</string>
    <string name="assistant_security_warning_title" msgid="6444187332360938730">"Želite li da <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> bude aplikacija za pomoć?"</string>
    <string name="assistant_security_warning" msgid="5623237187748811070">"Pomoćnik će moći da čita informacije o aplikacijama koje se koriste u sistemu, uključujući informacije koje mogu da se vide na ekranu ili kojima može da se pristupa u okviru  aplikacija."</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Prihvatam"</string>
    <string name="assistant_security_warning_disagree" msgid="1539182108068356410">"Ne prihvatam"</string>
    <string name="choose_voice_input_title" msgid="4855506199101586943">"Izaberite glasovni unos"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Aplikacija pregledača"</string>
    <string name="default_browser_title_none" msgid="4691907418284764833">"Nema podrazumevanog pregledača"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikacija Telefon"</string>
    <string name="default_app" msgid="445053777504688596">"(podrazumevano)"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistemska)"</string>
    <string name="system_default_app" msgid="2647834628622214931">"(Podrazumevana sistemska)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Memorija za aplikacije"</string>
    <string name="usage_access" msgid="5487993885373893282">"Pristup korišćenju"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Dozvoli pristup korišćenju"</string>
    <string name="app_usage_preference" msgid="7062447555623339120">"Podešavanja korišćenja aplikacija"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Vreme ispred ekrana"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Pristup korišćenju omogućava aplikaciji da prati koje druge aplikacije koristite i koliko često, kao i da vidi mobilnog operatera, jezička podešavanja i druge podatke."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memorija"</string>
    <string name="memory_details_title" msgid="3048107441540417799">"Detalji memorije"</string>
    <string name="always_running" msgid="9012705720688200252">"Uvek je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Ponekad je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Retko kada je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="8721866158069974846">"Maksimum"</string>
    <string name="memory_avg_use" msgid="4620476409349875703">"Prosek"</string>
    <string name="memory_max_desc" msgid="6966923521720393526">"Maks. <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="2632995851138152303">"Prosečno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="4239069158701023623">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimizacija baterije"</string>
    <string name="additional_battery_info" msgid="3104208543623068714">"Obaveštenja o korišćenju"</string>
    <string name="show_all_apps" msgid="4490719452453223082">"Prikaži korišćenje baterije"</string>
    <string name="hide_extra_apps" msgid="7313907836289865123">"Prikaži korišćenje aplikacija"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="573433136005336970">
      <item quantity="one"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija se ponaša na neuobičajen način</item>
      <item quantity="few"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacije se ponašaju na neuobičajen način</item>
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija se ponaša na neuobičajen način</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="8013115866788425817">
      <item quantity="one">Aplikacije mnogo troše bateriju</item>
      <item quantity="few">Aplikacije mnogo troše bateriju</item>
      <item quantity="other">Aplikacije mnogo troše bateriju</item>
    </plurals>
    <string name="high_power_filter_on" msgid="447849271630431531">"Bez optimizacije"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Bez optimizacije"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizacija korišćenja baterije"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimizacija baterije nije dostupna"</string>
    <string name="high_power_desc" msgid="2753076899835765338">"Ne primenjujte optimizaciju baterije. Može brže da isprazni bateriju."</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Dozvoljavate da aplikacija uvek bude aktivna u pozadini?"</string>
    <string name="high_power_prompt_body" msgid="6460557929559616041">"Ako dozvolite da aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> uvek bude aktivna u pozadini, to može da skrati trajanje baterije. \n\nKasnije možete to da promenite u odeljku Podešavanja &gt; Aplikacije i obaveštenja."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Potrošeno je <xliff:g id="PERCENTAGE">%1$s</xliff:g> od poslednjeg potpunog punjenja"</string>
    <string name="battery_power_management" msgid="7507188088567087384">"Upravljanje napajanjem"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Baterija nije korišćena od poslednjeg potpunog punjenja"</string>
    <string name="app_notification_preferences" msgid="2004680717999108725">"Podešavanja aplikacija"</string>
    <string name="system_ui_settings" msgid="936169564323330967">"Prikaži Tjuner za kor. interfejs sistema"</string>
    <string name="additional_permissions" msgid="4656871347558988462">"Dodatne dozvole"</string>
    <string name="additional_permissions_more" msgid="8188145515437525307">"još <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Želite li da podelite izveštaj o grešci?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"IT administrator je zatražio izveštaj o grešci radi lakšeg rešavanja problema u vezi sa ovim uređajem. Aplikacije i podaci mogu da se dele."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"IT administrator je zatražio izveštaj o grešci radi lakšeg rešavanja problema u vezi sa ovim uređajem. Aplikacije i podaci mogu da se dele, a uređaj će se privremeno usporiti."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Ovaj izveštaj o grešci se deli sa IT administratorom. Kontaktirajte ga za više detalja."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Deli"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Odbij"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Nema prenosa podataka"</string>
    <string name="usb_use_charging_only_desc" msgid="1234421230461847336">"Samo punite ovaj uređaj"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Napunite povezani uređaj"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Prenos datoteka"</string>
    <string name="usb_use_file_transfers_desc" msgid="1020257823387107336">"Prenosite datoteke na drugi uređaj"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="7490250033610745765">"Prenosite slike ili datoteke ako MTP nije podržan (PTP)"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB privezivanje"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="6464135515868405143">"Koristite ovaj uređaj kao MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Koristi USB za"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Podrazumevana USB konfiguracija"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Kad se poveže drugi uređaj, a telefon je otključan, primenjuju se ova podešavanja. Povezujte se samo sa pouzdanim uređajima."</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Podešavanja USB-a"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB kontroliše:"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Povezani uređaj"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Ovaj uređaj"</string>
    <string name="usb_switching" msgid="3713602881103295766">"Menja se..."</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Promena nije uspela"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Punjenje uređaja"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Punjenje povezanog uređaja"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Prenos datoteka"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB privezivanje"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Prenos datoteka i napajanje"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB privezivanje i napajanje"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP i napajanje"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI i napajanje"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Provera u pozadini"</string>
    <string name="background_check_title" msgid="225170874283229686">"Potpun pristup pozadini"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Koristi tekst sa ekrana"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Dozvolite aplikaciji za pomoć da pristupi sadržaju ekrana kao tekstu"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Koristi snimak ekrana"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Dozvolite aplikaciji za pomoć da pristupi slici ekrana"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Ekran sa treperenjem"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Neka ivice ekrana trepere kada aplikacija za pomoć pristupa tekstu na ekranu ili snimku ekrana"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Aplikacije za pomoć mogu da vam pomognu na osnovu informacija sa ekrana koji gledate. Neke aplikacije podržavaju usluge pokretača i glasovnog unosa da bi vam pružile integrisanu pomoć."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Prosečno korišćenje memorije"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimalno korišćenje memorije"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Korišćenje memorije"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Korišćenje aplikacije"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalji"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"U proseku je koristila <xliff:g id="SIZE">%1$s</xliff:g> u poslednja 3 sata"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Nije koristila memoriju u poslednja 3 sata"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sortiraj prema prosečnom korišćenju"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sortiraj prema maksimalnom korišćenju"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Učinak"</string>
    <string name="total_memory" msgid="5244174393008910567">"Ukupna memorija"</string>
    <string name="average_used" msgid="690235917394070169">"Prosek korišćenja (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Slobodno"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memorija koju koriste aplikacije"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="1355637088533572208">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija je koristila memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije su koristile memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija je koristilo memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="7260225121706316639">"Učestalost"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimum korišćenja"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Ne koriste se nikakvi podaci"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Želite li da dozvolite pristup podešavanju Ne uznemiravaj za <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikacija će moći da uključuje ili isključuje podešavanje Ne uznemiravaj i da unosi promene u srodna podešavanja."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Mora da ostane uključeno jer je pristup obaveštenjima uključen"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Želite li da opozovete pristup režimu Ne uznemiravaj za aplikaciju <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Uklonićemo sva pravila za režim Ne uznemiravaj koja je ova aplikacija napravila."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ne optimizuj"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizuj"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Baterija može brže da se isprazni. Aplikacijama više neće biti zabranjeno korišćenje baterije u pozadini."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Preporučeno za duže trajanje baterije"</string>
    <string name="ignore_optimizations_title" msgid="3464172726254542889">"Želite li da dozvolite aplikaciji <xliff:g id="APP">%s</xliff:g> da ignoriše optimizacije baterije?"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Ništa"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Isključivanje pristupa korišćenju za ovu aplikaciju ne sprečava administratora da prati potrošnju podataka za aplikacije na poslovnom profilu"</string>
    <string name="accessibility_lock_screen_progress" msgid="4597298121698665401">"Upotrebljeni znakovi: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_apps_title" msgid="1537949185175079866">"Aplikacije"</string>
    <string name="system_alert_window_access_title" msgid="3074573819155116817">"Prikaz preko drugih aplikacija"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Dozvoli prikaz preko drugih aplikacija"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Omogućite ovoj aplikaciji da se prikazuje preko drugih aplikacija koje koristite. Ova aplikacija će moći vidi gde dodirujete ili da promeni ono što se prikazuje na ekranu."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Pristup svim datotekama"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Dozvoli pristup za upravljanje svim datotekama"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Dozvolite da ova aplikacija čita, menja i briše sve datoteke na ovom uređaju ili svim povezanim uređajima za skladištenje. Ako to dozvolite, aplikacija može da pristupa datotekama bez vašeg znanja."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Može da pristupa svim datotekama"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtuelna realnost obrađivač usluga stereo pomagača"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_summary" msgid="1435856750594492891">"Aplikacije sa dozvolom za prikaz preko drugih: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikacije sa dozvolom"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Dozvoljeno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nije dozvoljeno"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instaliranje aplikacije nepoznati izvori"</string>
    <string name="write_settings" msgid="6864794401614425894">"Menjanje podešavanja sistema"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"upisivati menjati sistem podešavanja"</string>
    <string name="write_settings_summary" msgid="2085800775513476479">"<xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g> apl. ima(ju) dozvolu za izmenu podešavanja sistema"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Mogu da instaliraju druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Mogu da menjaju podešavanja sistema"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Mogu da menjaju podešavanja sistema"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Menjanje podešavanja sistema"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Dozvoli menjanje podešavanja sistema"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Ovo dozvoljava aplikaciji da menja podešavanja sistema."</string>
    <string name="write_settings_on" msgid="8533286548451191112">"Da"</string>
    <string name="write_settings_off" msgid="1781103034490679144">"Ne"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Dozvoli iz ovog izvora"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Dvaput zaokrenite za kameru"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Otvorite aplikaciju Kamera tako što ćete dvaput zaokrenuti ručni zglob"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="8264757967127716261">"Pritisnite dugme za napajanje dvaput za kameru"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="1539147023700755155">"Brzo otvorite kameru bez otključavanja ekrana"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Veličina prikaza"</string>
    <string name="screen_zoom_short_summary" msgid="2458636490408833800">"Omogućava da stavke na ekranu budu veće ili manje"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"gustina ekrana, zumiranje ekrana, razmera, prilagođavanje"</string>
    <string name="screen_zoom_summary" msgid="1362984939045594989">"Omogućava da stavke na ekranu budu manje ili veće. Položaj nekih aplikacija na ekranu može da se promeni."</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Pregled"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Umanji"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Uvećaj"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="2896036059049355968">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="4873109337506890558">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="2641317981482545659">"Zdravo, Petre!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6528272610590915790">"Hoćeš li da se ispričamo uz kafu danas?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="6930848361702066106">"Važi. Znam dobro mesto u blizini."</string>
    <string name="screen_zoom_conversation_message_4" msgid="2501043894465807210">"Savršeno!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="512353741016062507">"Uto 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="472183807915497199">"Uto 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="1659313906250856104">"Uto 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2046797647382623313">"Uto 18:03"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nije povezano"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nije povezana"</string>
    <string name="data_usage_summary_format" msgid="6844301859713164522">"Iskorišćeno je <xliff:g id="AMOUNT">%1$s</xliff:g> podataka"</string>
    <string name="data_usage_wifi_format" msgid="7644390582649568117">"<xliff:g id="AMOUNT">^1</xliff:g> potrošeno na Wi‑Fi mreže"</string>
    <plurals name="notification_summary" formatted="false" msgid="7638388920823212470">
      <item quantity="one">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikaciju</item>
      <item quantity="few">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikacije</item>
      <item quantity="other">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="notification_summary_none" msgid="9179312319023988089">"Uključeno za sve aplikacije"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Instaliranih aplikacija: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="apps_summary_example" msgid="6034002063446955592">"Instalirane su 24 aplikacije"</string>
    <string name="storage_summary" msgid="5903562203143572768">"U upotrebi <xliff:g id="PERCENTAGE">%1$s</xliff:g> – <xliff:g id="FREE_SPACE">%2$s</xliff:g> slobodno"</string>
    <string name="storage_summary_with_sdcard" msgid="2063780050580228868">"Interna memorija: <xliff:g id="PERCENTAGE">%1$s</xliff:g> je iskorišćeno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> je slobodno"</string>
    <string name="display_summary" msgid="5526061030874717172">"Pređi u režim spavanja posle <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="5102247404958535634">"Pozadina, režim spavanja, veličina fonta"</string>
    <string name="display_dashboard_summary_with_style" msgid="2792175367835485163">"Stilovi, pozadine, gašenje ekrana, veličina fonta"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="6198590533661927162">"Režim spavanja, veličina fonta"</string>
    <string name="display_summary_example" msgid="4275121979039344438">"Prelazak u režim spavanja posle 10 minuta neaktivnosti"</string>
    <string name="memory_summary" msgid="8221954450951651735">"U proseku je korišćeno <xliff:g id="USED_MEMORY">%1$s</xliff:g> od <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> memorije"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prijavljeni ste kao <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="5513009140568552693">"<xliff:g id="APP_NAME">%1$s</xliff:g> je podrazumevana"</string>
    <string name="backup_disabled" msgid="4503062265560959320">"Pravljenje rezervne kopije je onemogućeno"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Ažurirano na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Dostupno je ažuriranje"</string>
    <string name="disabled_by_policy_title" msgid="8296938784202750494">"Radnja nije dozvoljena"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Ne možete da promenite jačinu zvuka"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="2776004460663768982">"Pozivanje nije dozvoljeno"</string>
    <string name="disabled_by_policy_title_sms" msgid="6309460145439706922">"SMS-ovi nisu dozvoljeni"</string>
    <string name="disabled_by_policy_title_camera" msgid="8567781468959299078">"Kamera nije dozvoljena"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6137746705692573992">"Pravljenje snimaka ekrana nije dozvoljeno"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Ne možete da otvorite ovu aplikaciju"</string>
    <string name="default_admin_support_msg" msgid="8338570262037182531">"Ako imate pitanja, obratite se IT administratoru"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Još detalja"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Administrator može da nadgleda aplikacije i podatke povezane sa poslovnim profilom, uključujući podešavanja, dozvole, korporativni pristup, aktivnosti na mreži i informacije o lokaciji uređaja, kao i da upravlja njima."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Administrator može da nadgleda aplikacije i podatke povezane sa ovim korisnikom, uključujući podešavanja, dozvole, korporativni pristup, aktivnosti na mreži i informacije o lokaciji uređaja, kao i da upravlja njima."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Administrator može da prati aplikacije i podatke povezane sa ovim uređajem, uključujući podešavanja, dozvole, korporativni pristup, aktivnosti na mreži i informacije o lokaciji uređaja, kao i da upravlja njima."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Isključi"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Uključi"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Prikaži"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Sakrij"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot je aktivan"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Režim rada u avionu je uključen"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Mreže nisu dostupne"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Režim Ne uznemiravaj – uključen"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Zvuk na telefonu je isključen"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Uz izuzetke"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Ušteda baterije je uključena"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funkcije su ograničene"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobilni podaci su isključeni"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet je dostupan samo preko Wi‑Fi mreže"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Ušteda podataka"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funkcije su ograničene"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Poslovni profil je isključen"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Za aplikacije i obaveštenja"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Uključi zvuk"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Zvuk zvona je isključen"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Za pozive i obaveštenja"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Samo vibracija"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Za pozive i obaveštenja"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Podesite raspored za noćno svetlo"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Ekran se automatski zatamnjuje svake noći"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Noćno svetlo je uključeno"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Ekran ima žutu nijansu"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Sivilo"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Prikazuje se samo u sivoj boji"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Skupi"</string>
    <string name="suggestions_title_v2" msgid="421003737901460147">"Predloženo za vas"</string>
    <string name="suggestions_title" msgid="61841299295602686">"Predlozi"</string>
    <string name="suggestions_summary" msgid="1709710458908440469">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="240124526378997009">"i još <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="5023679825210836444">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> predlog</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> predloga</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> predloga</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="3789011332018516832">
      <item quantity="one">i još <xliff:g id="COUNT">%1$d</xliff:g> predlog</item>
      <item quantity="few">i još <xliff:g id="COUNT">%1$d</xliff:g> predloga</item>
      <item quantity="other">i još <xliff:g id="COUNT">%1$d</xliff:g> predloga</item>
    </plurals>
    <string name="suggestion_remove" msgid="6753986344585367776">"Ukloni"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Hladna temperatura boje"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Koristi hladnije boje ekrana"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Da biste primenili promenu boje, isključite ekran"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Senzor lasera Kamere"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatska ažuriranja sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Primeni ispravke kad se uređaj ponovo pokrene"</string>
    <string name="usage" msgid="287782903846013936">"Potrošnja"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Potrošnja mobil. podataka"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Korišćenje podataka aplikacije"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Potrošnja Wi-Fi podataka"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Potrošnja podataka na eternetu"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Eternet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobilnih podataka"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> Wi-Fi podataka"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> podataka na eternetu"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Upozorenje za podatke i ograničenje"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciklus potrošnje mobilnih podataka"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Upozorenje za potrošnju podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Ograničenje potrošnje podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Upozorenje za potrošnju podataka: <xliff:g id="ID_1">^1</xliff:g>/Ograničenje potrošnje podataka: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="6346655500491631357">"Svakog <xliff:g id="ID_1">%1$s</xliff:g>. u mesecu"</string>
    <string name="network_restrictions" msgid="8385824604048229846">"Mrežna ograničenja"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="3875128958788008975">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> ograničenje</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> ograničenja</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> ograničenja</item>
    </plurals>
    <string name="operator_warning" msgid="5672761970087591211">"Obračun podataka kod mobilnog operatera se možda razlikuje od obračuna uređaja."</string>
    <string name="data_used_template" msgid="8229342096562327646">"Potrošili ste <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Podesi upozorenje o podacima"</string>
    <string name="data_warning" msgid="2925054658166062884">"Upozorenje za potrošnju podataka"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Upozorenje za potrošnju podataka i ograničenje potrošnje podataka aktivira merenje uređaja. To može da se razlikuje od merenja mobilnog operatera."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Podesi ograničenje za podatke"</string>
    <string name="data_limit" msgid="8731731657513652363">"Ograničenje za potrošnju podataka"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Iskoristili ste <xliff:g id="ID_1">%1$s</xliff:g> u periodu <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurišite"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Druge aplikacije koje su trošile podatke"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="3316296488378947221">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija ima dozvolu da koristi neograničenu količinu podataka kada je Ušteda podataka uključena</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije imaju dozvolu da koriste neograničenu količinu podataka kada je Ušteda podataka uključena</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija ima dozvolu da koristi neograničenu količinu podataka kada je Ušteda podataka uključena</item>
    </plurals>
    <string name="data_usage_title" msgid="4039024073687469094">"Primarni podaci"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Wi‑Fi podaci"</string>
    <string name="data_used" msgid="7770571947591789895">"Potrošili ste <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> potrošeno"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> preko ograničenja"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Još <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafikon prikazuje potrošnju podataka između: <xliff:g id="START_DATE">%1$s</xliff:g> i <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Nema podataka iz ovog perioda"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="661792524671718753">
      <item quantity="one">Ostao je još %d dan</item>
      <item quantity="few">Ostala su još %d dana</item>
      <item quantity="other">Ostalo je još %d dana</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Vreme je isteklo"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Preostalo je manje od jednog dana"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Ažurirao operater <xliff:g id="ID_1">^1</xliff:g> pre <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Ažurirano je pre <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Malopre ažurirao operater <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Ažurirano je malopre"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Prikaži plan"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Prikaži detalje"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Ušteda podataka"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neograničen pristup podacima"</string>
    <string name="restrict_background_blacklisted" msgid="7953049316098373715">"Prenos podataka u pozadini je isključen"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Uključeno"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Isključeno"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Koristi Uštedu podataka"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neograničena potrošnja podataka"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Dozvoli neograničeni pristup podacima uz uključenu Uštedu podataka"</string>
    <string name="home_app" msgid="6056850504746902747">"Aplikacija za početnu stranicu"</string>
    <string name="no_default_home" msgid="3588073707316139318">"Nema podrazumevane početne stranice"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="4098653943835666086">"Bezbedno pokretanje"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="311325321794497404">"Zahtevanje šablona za pokretanje uređaja. Kada je isključen, uređaj ne može da prima pozive, poruke, obaveštenja niti alarme."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="1881271630312222251">"Zahtevanje PIN-a za pokretanje uređaja. Kada je isključen, uređaj ne može da prima pozive, poruke, obaveštenja niti alarme."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="8651761245246411947">"Zahtevanje lozinke za pokretanje uređaja. Kada je isključen, uređaj ne može da prima pozive, poruke, obaveštenja niti alarme."</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Dodajte još jedan otisak prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Otključavajte pomoću drugog prsta"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Uključeno"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Uključuje se na <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Isključeno"</string>
    <string name="battery_saver_button_turn_on" msgid="2206239048232352476">"Uključi"</string>
    <string name="battery_saver_button_turn_off" msgid="6371072408072481484">"Isključi"</string>
    <string name="not_battery_optimizing" msgid="8361294470943376258">"Ne koristi optimizaciju baterije"</string>
    <string name="lockscreen_remote_input" msgid="6030274311185811503">"Ako je uređaj zaključan, spreči unos odgovora ili drugog teksta u obaveštenja"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Podrazumevana provera pravopisa"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Izaberite proveru pravopisa"</string>
    <string name="spell_checker_master_switch_title" msgid="1233180004430328851">"Koristi proveru pravopisa"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nije izabrano"</string>
    <string name="notification_log_no_title" msgid="2343315128609978203">"(nijedno)"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"paket"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"šifra"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupa"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(rezime)"</string>
    <string name="notification_log_details_visibility" msgid="6811292866832243357">"vidljivost"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"javna verzija"</string>
    <string name="notification_log_details_priority" msgid="4772047133062255513">"prioritet"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"važnost"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"objašnjenje"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"može da prikazuje značku"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"namera"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"namera za brisanje"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"namera za ceo ekran"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"radnje"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"naslov"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"daljinski unosi"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"prilagođeni prikaz"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"bonus"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"veličina paketa"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"obaveštenje je poslato"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_none" msgid="1090852853755089991">"nijedno"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Nedostaje objekat za rangiranje."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Objekat za rangiranje ne sadrži ovu šifru."</string>
    <string name="theme_customization_device_default" msgid="7641813022590999286">"Podrazumevano podešavanje za uređaj"</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Izrez ekrana"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"izrezana slika za ekran, urez"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Podrazumevano podešavanje za uređaj"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Primena preklopnog elementa nije uspela"</string>
    <string name="special_access" msgid="1767980727423395147">"Poseban pristup aplikaciji"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija može da koristi neograničenu količinu podataka</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije mogu da koriste neograničenu količinu podataka</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija može da koristi neograničenu količinu podataka</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Prikaži još"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="3783325656948378111">"Želite li stvarno da izbrišete podatke korisnika i da konvertujete u šifrovanje datoteka?"</string>
    <string name="button_confirm_convert_fbe" msgid="339648921918438106">"Izbriši i konvertuj"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Resetuj ograničavanje broja u ShortcutManager-u"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Ograničavanje broja u ShortcutManager-u je resetovano"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrolišite informacije na zaključanom ekranu"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Pregledajte ili sakrijte sadržaj obaveštenja"</string>
    <string name="page_tab_title_summary" msgid="7188875610123234454">"Sve"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Saveti i podrška"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Najmanja širina"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nijedna instalirana aplikacija nije zahtevala pristup premijum SMS-ovima"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Premijum SMS-ovi mogu da koštaju i povećaće račune kod mobilnog operatera. Ako omogućite dozvolu za neku aplikaciju, moći ćete da šaljete premijum SMS-ove pomoću te aplikacije."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Pristup premijum SMS-ovima"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Isključeno"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Povezan je sa uređajem <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Povezan je sa više uređaja"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Režim demonstracije za korisnički interfejs sistema"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tamna tema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="3936676430482852520">"Uključeno/Privremeno onemogućeno zbog Uštede baterije"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Privremeno uključeno zbog Uštede baterije"</string>
    <string name="dark_ui_settings_dark_summary" msgid="1214821092462388494">"Podržane aplikacije će takođe preći na tamnu temu"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="250437497729953965">"Važi"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Isprobaj Tamnu temu"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pomaže da produžite trajanje baterije"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Pločice programera za brza podešavanja"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Onemogućite vremensko ograničenje ovlašćenja adb-a"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Onemogućite automatsko opozivanje ovlašćenja adb-a za sisteme koji se ne povežu ponovo tokom podrazumevanog vremenskog perioda (7 dana) ili vremenskog perioda koji konfiguriše korisnik (najmanje 1 dan)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Winscope trag"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Senzori su isključeni"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Podešavanja poslovnog profila"</string>
    <string name="managed_profile_contact_search_title" msgid="7685402733942182110">"Pretraga kontakata"</string>
    <string name="managed_profile_contact_search_summary" msgid="2771343453017731940">"Dozvolite da pretraživanje kontakata od strane vaše organizacije identifikuje pozivaoce i kontakte."</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendar za više vrsta profila"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Prikazivanje poslovnih događaja u ličnom kalendaru"</string>
    <plurals name="hours" formatted="false" msgid="1853396353451635458">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> sat</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> sata</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sati</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="6244503272924425418">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> minut</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> minuta</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minuta</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="4237020272336995370">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> sekunda</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> sekunde</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekundi</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Upravljaj memorijskim prostorom"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Da bi oslobodio memorijski prostor, menadžer memorijskog prostora uklanja rezervne kopije slika i video snimaka sa uređaja."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Uklonite slike i video"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Menadžer memorijskog prostora"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="8492707479615609185">"Koristi Menadžer memorijskog prostora"</string>
    <string name="deletion_helper_automatic_title" msgid="597196990024769472">"Automatska"</string>
    <string name="deletion_helper_manual_title" msgid="1068812971600327101">"Ručna"</string>
    <string name="deletion_helper_preference_title" msgid="6364023246849161274">"Oslobodi prostor"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Pokreti"</string>
    <string name="gesture_preference_summary" product="default" msgid="7941981260703379398">"Brzi pokreti za kontrolu telefona"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4031666250963488007">"Brzi pokreti za kontrolu tableta"</string>
    <string name="gesture_preference_summary" product="device" msgid="3520072325356373349">"Brzi pokreti za kontrolu uređaja"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Brzo otvaraj kameru"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Da biste brzo otvorili kameru, dvaput pritisnite dugme za napajanje. Ovo funkcioniše na svakom ekranu."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="4299496243418753571">"Brzo otvorite kameru"</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Obrnite kameru da biste snimili selfi"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="8178844037382604158">"Brže snimajte selfije"</string>
    <string name="system_navigation_title" msgid="1698862900901417194">"Navigacija kroz sistem"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigacija pomoću 2 dugmeta"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Da biste prešli sa jedne aplikacije na drugu, prevucite nagore na dugmetu Početak. Da biste videli sve aplikacije, ponovo prevucite nagore. Da biste se vratili, dodirnite dugme Nazad."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="5754081720589900007">"Isprobajte novo dugme Početak"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="8885866570559435110">"Uključite novi pokret da biste prešli na drugu aplikaciju"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigacija pomoću pokreta"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Da biste otišli na početni ekran, prevucite nagore od dna ekrana. Da biste prešli sa jedne aplikacije na drugu, prevucite nagore od dna ekrana, zadržite, pa pustite. Da biste se vratili nazad, prevucite od leve ili desne ivice."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigacija pomoću 3 dugmeta"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Vratite se nazad, pristupite početnom ekranu i prelazite sa jedne aplikacije na drugu pomoću dugmadi u dnu ekrana."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigacija kroz sistem, navigacija pomoću 2 dugmeta, navigacija pomoću 3 dugmeta, navigacija pomoću pokreta, prevlačenje"</string>
    <string name="gesture_not_supported_dialog_message" msgid="5316512246119347889">"Ne podržava podrazumevana aplikacija početne stranice, <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g>"</string>
    <string name="gesture_not_supported_positive_button" msgid="7909969459977021893">"Promeni podraz. aplikaciju poč. stranice"</string>
    <string name="information_label" msgid="6939310810756569298">"Informacije"</string>
    <string name="low_label" msgid="6525629096999711220">"Niska"</string>
    <string name="high_label" msgid="357503396626018487">"Visoka"</string>
    <string name="left_edge" msgid="1513576842959071849">"Leva ivica"</string>
    <string name="right_edge" msgid="1505309103265829121">"Desna ivica"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Veća osetljivost može da izazove neslaganje sa pokretima u aplikaciji duž ivica ekrana."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Pozadinska osetljivost"</string>
    <string name="gesture_settings_activity_title" msgid="6047431928567911330">"Podešavanja pokreta"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigacija pomoću pokreta, osetljivost pokreta za nazad, pokret za nazad"</string>
    <string name="ambient_display_title" product="default" msgid="5885136049497127396">"Dvaput dodirnite telefon da biste ga proverili"</string>
    <string name="ambient_display_title" product="tablet" msgid="205744440641466921">"Dvaput dodirnite tablet da biste ga proverili"</string>
    <string name="ambient_display_title" product="device" msgid="4164103424628824786">"Dvaput dodirnite uređaj da biste ga proverili"</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Da biste proverili vreme, obaveštenja i druge informacije, dvaput dodirnite ekran."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="4418310591912877548">"Podignite telefon da biste ga proverili"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="8055486872070888377">"Podignite tablet da biste ga proverili"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="8980156994848721455">"Podignite uređaj da biste ga proverili"</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Probudite ekran"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="1087355013674109242">"Da biste proverili vreme, obaveštenja i druge informacije, uzmite telefon."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="2589556997034530529">"Da biste proverili vreme, obaveštenja i druge informacije, uzmite tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="1916011370011115627">"Da biste proverili vreme, obaveštenja i druge informacije, uzmite uređaj."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="2811332293938467179">"Dodirnite da biste proverili telefon"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="6461531447715370632">"Dodirnite da biste proverili tablet"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="4423803387551153840">"Dodirnite da biste proverili uređaj"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Da biste proverili vreme, obaveštenja i druge informacije, dodirnite ekran."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Prevucite prstom za obaveštenja"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Prevucite prstom"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="286662791588779673">"Da biste proverili obaveštenja, prevucite prstom nadole po senzoru za otisak prsta na zadnjoj strani telefona."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="8642092907817554454">"Da biste proverili obaveštenja, prevucite prstom nadole po senzoru za otisak prsta na zadnjoj strani tableta."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="3888927017311372398">"Da biste proverili obaveštenja, prevucite prstom nadole po senzoru za otisak prsta na zadnjoj strani uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Brzo pregledajte obaveštenja"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Uključeno"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Isključeno"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Alatka za pokretanje operativnog sistema je već otključana"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="8045017109714463041">"Prvo se povežite na internet"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Povežite se na internet ili kontaktirajte mobilnog operatera"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nije dostupno na uređajima koje je mobilni operater zaključao"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Restartujte uređaj da biste omogućili funkciju zaštite uređaja."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Postalo je dostupno ukupno <xliff:g id="SIZE">%1$s</xliff:g>\n\nPoslednji put pokrenuto <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant aplikacije"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Otvaraj linkove u aplikacijama, čak i ako nisu instalirane"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant aplikacije"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Podešavanja instant aplikacija"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Instalirane aplikacije"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Memorijskim prostorom sada upravlja Menadžer memorijskog prostora"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Nalozi korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="3126887329521705210">"Konfigurišite"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automatski sinhronizuj podatke aplikacija"</string>
    <string name="auto_sync_personal_account_title" msgid="3544275021920818595">"Automatski sinhronizuj lične podatke"</string>
    <string name="auto_sync_work_account_title" msgid="6060310415978781885">"Automatske sinhronizuj poslovne podatke"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Omogući aplikacijama da automatski osvežavaju podatke"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sinhronizacija naloga"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinhronizacija je uključena za neke stavke (<xliff:g id="ID_1">%1$d</xliff:g> od <xliff:g id="ID_2">%2$d</xliff:g>)"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinhronizacija je uključena za sve stavke"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinhronizacija je isključena za sve stavke"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informacije o uređaju kojim se upravlja"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Promene i podešavanja kojima upravlja organizacija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Promene i podešavanja kojima upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Organizacija može da promeni podešavanja i da instalira softver na uređaju radi omogućavanja pristupa poslovnim podacima. \n\nObratite se administratoru organizacije za dodatne informacije."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Vrste informacija koje organizacija može da vidi"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Promene koje je uneo administrator organizacije"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Pristup ovom uređaju"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Podaci povezani sa poslovnim nalogom, poput imejla i kalendara"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lista aplikacija na uređaju"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Količina vremena i podataka potrošena u svakoj aplikaciji"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Najnovija evidencija o mrežnom saobraćaju"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Najnoviji izveštaj o grešci"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Najnovija bezbednosna evidencija"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Nema"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Aplikacije su instalirane"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Broj aplikacija predstavlja procenu. Možda ne obuhvata aplikacije instalirane izvan Play prodavnice."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="5403847001419529018">
      <item quantity="one">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
      <item quantity="few">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Dozvole za lokaciju"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Dozvole za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Dozvole za kameru"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Podrazumevane aplikacije"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="8568544906431825430">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Podrazumevana tastatura"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Podešeno je na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Stalno uključen VPN je uključen"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Stalno uključen VPN je uključen na ličnom profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Stalno uključen VPN je uključen na poslovnom profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Globalni HTTP proksi je podešen"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Pouzdani akreditivi"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Pouzdani akreditivi na ličnom profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Pouzdani akreditivi na poslovnom profilu"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="6459725295322004179">
      <item quantity="one">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> CA sertifikat</item>
      <item quantity="few">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> CA sertifikata</item>
      <item quantity="other">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> CA sertifikata</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administrator može da zaključava uređaj i resetuje lozinku"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administrator može da briše sve podatke sa uređaja"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Neuspeli pokušaji unosa lozinke pre brisanja svih podataka sa uređaja"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Neuspeli pokušaji unosa lozinke pre brisanja podataka sa poslovnog profila"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="8811973918944217791">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> pokušaj</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> pokušaja</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> pokušaja</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Ovim uređajem upravlja organizacija."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Ovim uređajem upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Saznajte više"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="8112432929729136399">
      <item quantity="one">aplikacija za kameru</item>
      <item quantity="few">aplikacije za kameru</item>
      <item quantity="other">aplikacije za kameru</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikacija Kalendar"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikacija Kontakti"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="8338194872609410234">
      <item quantity="one">aplikacija za imejl klijent</item>
      <item quantity="few">aplikacije za imejl klijent</item>
      <item quantity="other">aplikacije za imejl klijent</item>
    </plurals>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikacija za mape"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="4222188821845826493">
      <item quantity="one">aplikacija Telefon</item>
      <item quantity="few">aplikacije Telefon</item>
      <item quantity="other">aplikacija Telefon</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="6926197783745481869">"Slike i video snimci"</string>
    <string name="storage_music_audio" msgid="1185624135490182822">"Muzika i audio"</string>
    <string name="storage_games" msgid="1176568610086802469">"Igre"</string>
    <string name="storage_other_apps" msgid="5902520888043081176">"Druge aplikacije"</string>
    <string name="storage_files" msgid="7968460921272772299">"Datoteke"</string>
    <string name="storage_size_large_alternate" msgid="7555149858858591495">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="7102720999351050601">"Iskorišćeno od ukupno <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="7211888326013020857">"u upot."</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Obriši aplikaciju"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Želite li da uklonite ovu instant aplikaciju?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Otvori"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Igre"</string>
    <string name="audio_files_title" msgid="5981409295669041303">"Audio datoteke"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Iskorišćen prostor"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(deinstalirano za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(onemogućeno za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Usluga automatskog popunjavanja"</string>
    <string name="autofill_keywords" msgid="6260653325195017912">"automatski, popunjavanje, automatsko popunjavanje"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Uverite se da je ova aplikacija pouzdana&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google automatsko popunjavanje&gt;%1$s&lt;/xliff:g&gt; koristi sadržaj ekrana za utvrđivanje podataka koji mogu automatski da se popune."</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatsko popunjavanje"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Nivo evidentiranja"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maksimalan broj zahteva po sesiji"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maksimalan broj vidljivih skupova podataka"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Resetuj na podrazumevane vrednosti"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Opcije za programera za automatsko popunjavanje su resetovane"</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema uređaja"</string>
    <string name="default_theme" msgid="4815428567082263639">"Podrazumevana"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Naziv mreže"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Prikazuje naziv mreže na statusnoj traci"</string>
    <string name="storage_manager_indicator" msgid="6187509172735927297">"Menadžer memorijskog prostora: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="2705959642617709265">"Isključeno"</string>
    <string name="storage_manager_indicator_on" msgid="8380330763647785309">"Uključeno"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant aplikacija"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Želite li da isključite menadžer memorijskog prostora?"</string>
    <string name="storage_movies_tv" msgid="7897612625450668593">"Aplikacije za filmove i TV"</string>
    <string name="carrier_provisioning" msgid="7217868336140325816">"Informacije o dodeli mobilnog operatera"</string>
    <string name="trigger_carrier_provisioning" msgid="3288805742683538597">"Pokretanje dodele mobilnog operatera"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Ažurirajte režim Ne uznemiravaj"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pauzirajte obaveštenja radi bolje koncentracije"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcija nije dostupna"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Ova funkcija je isključena jer usporava telefon"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Prinudno pokreni puna GNSS merenja"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Prati sve GNSS konstalacije i frekvencije bez ciklusa rada"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Uvek prikazuj dijalog o otkazivanju"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Prikaži dijalog svaki put kada aplikacija otkaže"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Izaberi aplikaciju omogućenu za ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nije podešena aplikacija omogućena za ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikacija omogućena za ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Podešavanja upravljačkog programa za grafiku"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Izmena podešavanja upravljačkog programa za grafiku"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kada postoji više upravljačkih programa za grafiku, možete da izaberete da koristite ažurirani upravljački program za grafiku za aplikacije instalirane na uređaju."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Omogući za sve aplikacije"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Izaberite upravljački program za grafiku"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Podrazumevano"</string>
    <string name="graphics_driver_app_preference_game_driver" msgid="3115277644656023504">"Upravljački program za igre"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Upravljački program za programere"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Sistemski upravljački program za grafiku"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Promene kompatibilnosti aplikacije"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Uključite/isključite promene kompatibilnosti aplikacije"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Podrazumevane omogućene promene"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Podrazumevane onemogućene promene"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Nema aplikacija"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Promene kompatibilnosti aplikacija mogu da se izmene samo za aplikacije sa otklonjivim greškama. Instalirajte aplikaciju sa otklonjivim greškama i probajte ponovo."</string>
    <string name="unsupported_setting_summary" product="default" msgid="1085229417771470172">"Podešavanje nije podržano na ovom telefonu"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="7402414129786489664">"Podešavanje nije podržano na ovom tabletu"</string>
    <string name="unsupported_setting_summary" product="device" msgid="3422953459122926833">"Podešavanje nije podržano na ovom uređaju"</string>
    <string name="disabled_for_user_setting_summary" msgid="9096036019081828639">"Aktuelni korisnik ne može da promeni podešavanje"</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Zavisi od drugog podešavanja"</string>
    <string name="unknown_unavailability_setting_summary" msgid="9060213910510360231">"Podešavanje je nedostupno"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Nalog"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Naziv uređaja"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Kontrola Wi-Fi veze"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Omogućite da aplikacija kontroliše Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Omogućite da ova aplikacija uključi ili isključi Wi-Fi, traži i povezuje se na Wi-Fi mreže, dodaje i uklanja mreže ili pokreće samo lokalni hotspot"</string>
    <string name="media_output_title" msgid="8283629315159510680">"Puštaj medijski sadržaj na"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Pusti <xliff:g id="LABEL">%s</xliff:g> na"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Ovaj uređaj"</string>
    <string name="media_output_summary" product="default" msgid="4760338801715262899">"Telefon"</string>
    <string name="media_output_summary" product="tablet" msgid="5138101426462250247">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="3598300438694764381">"Uređaj"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Nedostupno tokom poziva"</string>
    <string name="media_output_summary_unavailable" msgid="2695058965888813093">"Nedostupno"</string>
    <string name="media_output_group_panel_title" msgid="3086245179062913037">"Dodajte izlaze"</string>
    <string name="media_output_group" msgid="7918231774595274396">"Grupa"</string>
    <string name="media_output_group_panel_single_device_summary" msgid="5027884071572180516">"Izabran je 1 uređaj"</string>
    <string name="media_output_group_panel_multiple_devices_summary" msgid="4838305763151455248">"Izabranih uređaja: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="media_output_switching" msgid="7488216595474868546">"Menja se…"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Preuzmi poziv"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Naziv pristupne tačke ne može da se menja."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="1525940496459255289">"Produžite trajanje baterije tableta"</string>
    <string name="battery_suggestion_title" product="device" msgid="2280773774080720377">"Produžite trajanje baterije uređaja"</string>
    <string name="battery_suggestion_title" product="default" msgid="4811554469047272537">"Produžite trajanje baterije telefona"</string>
    <string name="battery_suggestion_summary" msgid="8186720080540016197"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Sprečite zvonjenje"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Dugme za napajanje i pojačavanje zvuka odjednom:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Prečica za sprečavanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibriraj"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Isključi zvuk"</string>
    <string name="prevent_ringing_option_none" msgid="7776676007180834163">"Ne radi ništa"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="5649569082721304741">"Uključeno (vibracija)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4885288334872920616">"Uključeno (zvuk je isključen)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="7004926708584574224">"Isključeno"</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detalji o mreži"</string>
    <string name="about_phone_device_name_warning" msgid="764557372426153827">"Ime uređaja vide aplikacije na telefonu. Mogu da ga vide i drugi ljudi kad se povežete sa Bluetooth uređajima ili podesite Wi-Fi hotspot."</string>
    <string name="devices_title" msgid="649715719278562515">"Uređaji"</string>
    <string name="homepage_all_settings" msgid="1877827279189801035">"Sva podešavanja"</string>
    <string name="homepage_personal_settings" msgid="8312279476519359656">"Predlozi"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Odaberite mrežu"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Veza je prekinuta"</string>
    <string name="network_connected" msgid="7637745547242487795">"Povezano"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Povezuje se…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Povezivanje nije uspelo"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nije pronađena nijedna mreža."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nismo uspeli da pronađemo mreže. Probajte ponovo."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(zabranjeno)"</string>
    <string name="no_sim_card" msgid="1497407489810953863">"Nema SIM kartice"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Nema SIM kartice"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Nema"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Neophodan je SIM radi povezivanja"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Neophodan je <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> SIM radi povezivanja"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Željeni režim mreže: WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Željeni režim mreže: samo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Željeni režim mreže: samo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Željeni režim mreže: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Željeni režim mreže: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Željeni režim mreže: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Željeni režim mreže: samo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Željeni režim mreže: samo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Željeni režim mreže: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Željeni režim mreže: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Željeni režim mreže: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Željeni režim mreže: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Željeni režim mreže: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Željeni režim mreže: Globalno"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Željeni režim mreže: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Željeni mrežni režim: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Željeni režim mreže: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Željeni režim mreže: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Željeni režim mreže: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Željeni režim mreže: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Željeni režim mreže: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Željeni režim mreže: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Željeni režim mreže: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Željeni režim mreže: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Željeni režim mreže: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Željeni režim mreže: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Željeni režim mreže: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Željeni režim mreže: samo NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Željeni režim mreže: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Željeni režim mreže: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Željeni režim mreže: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Željeni režim mreže: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Željeni režim mreže: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Željeni režim mreže: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Željeni režim mreže: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Željeni režim mreže: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Željeni režim mreže: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Željeni režim mreže: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_recommended" msgid="4665525658003183348">" (preporučeno)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (preporučeno)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (preporučeno)"</string>
    <string name="label_available" msgid="5305726869955838606">"Dostupne mreže"</string>
    <string name="load_networks_progress" msgid="4717874401621250401">"Pretražuje se…"</string>
    <string name="register_on_network" msgid="2169662800750709709">"Registrujete se na mrežu <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="5756935665192962915">"SIM kartica ne dozvoljava vezu sa ovom mrežom."</string>
    <string name="connect_later" msgid="2330538069949281352">"Trenutno nije moguće povezati se sa ovom mrežom. Probajte ponovo kasnije."</string>
    <string name="registration_done" msgid="1750434215698850123">"Registrovano na mreži."</string>
    <string name="select_automatically" msgid="2419752566747259155">"Automatski izaberi mrežu"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Podešavanja operatera"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Podesite usl. prenosa podataka"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobilni podaci"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Koristi podatke preko mobilne mreže"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon će automatski preći na ovog operatera kada bude u dometu"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Podešavanje poziva"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Željena podešavanja za SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Pitaj svaki put"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Dodajte mrežu"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="5173633860800230925">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM kartica</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM kartice</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM kartica</item>
    </plurals>
    <string name="default_for_calls" msgid="2788950217176988034">"Podrazumevano za pozive"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Podrazumevano za SMS-ove"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Podrazumevano za pozive i SMS-ove"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Podrazumevano za mobilne podatke"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobilni podaci su aktivni"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobilni podaci su isključeni"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Dostupna"</string>
    <string name="mobile_network_in_range" msgid="3528320750936028369">"U dometu"</string>
    <string name="mobile_network_not_in_range" msgid="5680896182395366584">"Nije u dometu"</string>
    <string name="mobile_network_list_add_more" msgid="4478586073355236604">"Dodajte još"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktivno/SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktivno/SIM"</string>
    <string name="mobile_network_active_esim" msgid="4673190244386572318">"Aktivno/preuzeti SIM"</string>
    <string name="mobile_network_inactive_esim" msgid="2901035056727849007">"Neaktivno/preuzeti SIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Naziv i boja SIM kartice"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Ime"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Boja (koriste kompatibilne aplikacije)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Sačuvaj"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Koristi SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Isključeno"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Da biste onemogućili ovu SIM karticu, uklonite je"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Dodirnite da biste aktivirali <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="2762744961192218789">"Želite li da pređete na <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="8168680839542031781">"U datom trenutku može da bude aktivna samo jedna SIM kartica.\n\nPrebacivanje na <xliff:g id="CARRIER1">%1$s</xliff:g> neće otkazati <xliff:g id="CARRIER2">%2$s</xliff:g> uslugu."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8695772737522378095">"Pređi na <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Obriši SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="6680959559589234726">"Brisanje SIM-a nije uspelo"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6401922869095572710">"Ovaj SIM ne može da se obriše zbog greške.\n\nRestartujte uređaj i probajte ponovo."</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Željeni tip mreže"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Promena režima rada mreže"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Željeni tip mreže"</string>
    <string name="carrier_settings_euicc" msgid="1541279297111378907">"Mobilni operater"</string>
    <string name="carrier_settings_version" msgid="4738147451583140935">"Verzija podešavanja"</string>
    <string name="call_category" msgid="641461844504128789">"Pozivanje"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Video pozivanje preko operatera"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Izbor sistema"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Promena režima CDMA rominga"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Izbor sistema"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Mreža"</string>
    <string name="network_select_title" msgid="4532395144000206685">"Mreža"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA prijava"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Promenite mrežu sa RUIM/SIM na NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"prijava"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatska registracija..."</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Želite li da dozvolite prenos podataka u romingu?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Cene proverite kod mobilnog operatera."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Potrošnja podataka aplikacije"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Nevažeći režim mreže <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorišite."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Nazivi pristupnih tačaka"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nedostupno kada je uspostavljena veza sa operaterom <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Prikaži još"</string>
    <string name="see_less" msgid="2642392725363552793">"Prikaži manje"</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Povežite se sa uređajem"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplikacija <xliff:g id="APPNAME">%1$s</xliff:g> želi da koristi privremenu Wi‑Fi mrežu da bi se povezala sa uređajem"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nije pronađen nijedan uređaj Proverite da li je uređaj uključen i dostupan za povezivanje."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Probaj ponovo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Došlo je do nekog problema. Aplikacija je otkazala zahtev za izbor uređaja."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Povezivanje je uspelo"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Povezivanje nije uspelo"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Prikaži sve"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Traži se uređaj…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Povezuje se sa uređajem…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Levo"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Desno"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Futrola"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Tabla sa podešavanjima"</string>
    <string name="internet_connectivity_panel_title" msgid="2044237561024730108">"Povezivanje na internet"</string>
    <string name="volume_connectivity_panel_title" msgid="8772438444782726321">"Jačina zvuka"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="6067959496888990983">"Nedostupno tokom režima rada u avionu"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Nametni režim računara"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Nametni eksperimentalni režim računara na sekundarnim ekranima"</string>
    <string name="enable_sizecompat_freeform" msgid="3799755160777404309">"Omogući slobodni oblik aplikacija sa nepromenjivom veličinom"</string>
    <string name="enable_sizecompat_freeform_summary" msgid="1484050174538201499">"Omogućava aplikacijama sa nepromenjivom veličinom da budu u slobodnom obliku"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Zameni funkciju nametanja tamne teme"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Menja funkciju nametanja tamne teme tako da bude uvek uključena"</string>
    <string name="enable_blurs_on_windows_title" msgid="4218144213800778872">"Omogući zamagljivanja"</string>
    <string name="enable_blurs_on_windows_summary" msgid="8962906921531490386">"Omogućava zamagljivanja ekrana na nivou sastavljača. Zahteva restartovanje uređaja."</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privatnost"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Dozvole, aktivnost naloga, lični podaci"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Ukloni"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Zadrži"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Želite li da uklonite ovaj predlog?"</string>
    <string name="contextual_card_removed_message" msgid="5755438207494260867">"Predlog je uklonjen"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="5200381837316691406">"Opozovi"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Nema mnogo prostora. <xliff:g id="PERCENTAGE">%1$s</xliff:g> je iskorišćeno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> je slobodno"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Pošaljite povratne informacije"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Želite li da nam pošaljete povratne informacije za ovaj predlog?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Kopirano je u privremenu memoriju: <xliff:g id="COPY_CONTENT">%1$s</xliff:g>"</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="permission_bar_chart_empty_text" msgid="4856719891991325077">"Nijedna aplikacija nije koristila dozvole"</string>
    <string name="permission_bar_chart_title" msgid="2493212904955611441">"Korišćenje dozvola u poslednja 24 sata"</string>
    <string name="permission_bar_chart_details" msgid="5816698018592357088">"Prikaži sve na kontrolnoj tabli"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="4853396794340896078">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> aplikacija</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> aplikacije</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> aplikacija</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Korišćenje Pristupačnosti"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="6910643986958263005">
      <item quantity="one"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacija imaju potpun pristup uređaju</item>
      <item quantity="few"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacije imaju potpun pristup uređaju</item>
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacija ima potpun pristup uređaju</item>
    </plurals>
    <string name="media_output_panel_title" msgid="5920946795078065159">"Promenite izlaz"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="6998758947764222915">"Trenutno se pušta na uređaju <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="media_output_disconnected_status" msgid="5567111639832431865">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> (veza je prekinuta)"</string>
    <string name="media_output_switch_error_text" msgid="603563475910236831">"Prebacivanje nije uspelo. Probajte opet."</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Važne informacije"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"NASTAVI"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NE, HVALA"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Lokacija"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="2799241640320172899">"Dobavljač usluge može da prikuplja informacije o lokaciji da bi pružao ovu uslugu.\n\nPregledajte politiku privatnosti dobavljača usluge."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Možete da izgubite pristup preostalom vremenu ili podacima. Proverite sa dobavljačem usluge pre uklanjanja."</string>
    <string name="keywords_content_capture" msgid="7802155522681936956">"snimanje sadržaja, sadržaj aplikacije"</string>
    <string name="content_capture" msgid="868372905432812238">"Sadržaj aplikacije"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Dozvolite aplikacijama da šalju sadržaj Android sistemu"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Snimi dinamički deo memorije sistema"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Snimanje dinamičkog dela memorije sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Snimanje dinamičkog dela memorije sistema nije uspelo"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automatski snimaj dinamički deo memorije sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automatski snima dinamički deo memorije za Android sistem kada koristi previše memorije"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Prekini vezu"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Hitni pozivi"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Mobilni operater ne podržava hitne pozive pomoću funkcije Pozivanje preko Wi-Fi-ja.\nUređaj automatski prelazi na mobilnu mrežu da bi uputio hitan poziv.\nHitni pozivi su mogući samo u oblastima pokrivenim mobilnom mrežom."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Koristite Wi‑Fi za pozive da biste poboljšali kvalitet"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Dolazna MMS poruka"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Slanje MMS poruka nije moguće"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Dodirnite da biste omogućili slanje MMS poruka na uređaju <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> kada su mobilni podaci isključeni"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS poruka"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problem sa SIM kombinacijom"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Funkcionalnost može da bude ograničena ako koristite operatere <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g>. Dodirnite da biste saznali više."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM kombinacija"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informacije o smernicama za posao"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Podešavanjima upravlja IT administrator"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Obrađivač izveštaja o grešci"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Određuje koja aplikacija upravlja prečicom za izveštaj o grešci na uređaju."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Lično"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Poslovni"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Podrazumevana sistemska"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Ovaj izbor više nije važeći. Probajte ponovo."</string>
    <string name="device_controls_sentence" msgid="4887752349920801907">"Kontrole uređaja"</string>
    <string name="quick_controls_lower" msgid="6675573610027367819">"kontrole uređaja"</string>
    <string name="cards_passes_sentence" msgid="1866311782387946944">"Karte i kartice"</string>
    <string name="cards_passes_lower" msgid="2429722007109957877">"karte i kartice"</string>
    <string name="power_menu_setting_name" msgid="7843519296976254765">"Meni za uključivanje"</string>
    <string name="power_menu_setting_title" msgid="7716546106215378956">"Meni dugmeta za uključivanje"</string>
    <string name="power_menu_cards_passes" msgid="1707852019651773645">"Prikazuj karte i kartice"</string>
    <string name="power_menu_device_controls" msgid="5114816270328063924">"Prikaži kontrole uređaja"</string>
    <string name="power_menu_cards_passes_device_controls" msgid="8645794247280620106">"Prikazuj karte, kartice i kontrole uređaja"</string>
    <string name="power_menu_lock_screen_category" msgid="1478249026305417128">"Zaključani ekran"</string>
    <string name="power_menu_none" msgid="4620640577918731270">"Ne prikazuj nikakav sadržaj"</string>
    <string name="power_menu_privacy" msgid="7900052501075197854">"Osetljiv sadržaj"</string>
    <string name="power_menu_privacy_show" msgid="2112741022037054383">"Prikazuj kartice i kontrole kada je uređaj zaključan"</string>
    <string name="power_menu_privacy_show_controls" msgid="8294874046577167797">"Prikazuj kontrole na zaključanom ekranu"</string>
    <string name="power_menu_privacy_show_cards" msgid="8937303188629541026">"Prikazuj kartice na zaključanom ekranu"</string>
    <string name="power_menu_privacy_hide" msgid="1617102911157977095">"Sakrij kartice i kontrole kada je uređaj zaključan"</string>
    <string name="power_menu_privacy_not_secure" msgid="6247119934128206924">"Radi korišćenja, prvo podesite zaključavanje ekrana"</string>
    <string name="device_controls_setting_toggle" msgid="8972005569207737469">"Prikaži kontrole uređaja"</string>
    <string name="cards_passes_setting_toggle" msgid="3380984848045396695">"Prikaži kreditne i druge kartice"</string>
    <string name="device_controls_setting_subtitle" msgid="4388544861427973600">"Da biste pristupili kontrolama za povezane uređaje, zadržite dugme za uključivanje"</string>
    <string name="cards_passes_setting_subtitle" msgid="4427459738229697469">"Da biste pristupali načinima plaćanja, bording kartama i sličnim stvarima, pritisnite i zadržite dugme za uključivanje."</string>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="media_output_panel_stop_casting_button" msgid="6094875883164119035">"Zaustavi prebacivanje"</string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Želite li da isključite VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Time ćete isključiti i 5G vezu.\nTokom glasovnog poziva ne možete da koristite internet i neke aplikacije možda neće raditi."</string>
    <string name="no_5g_in_dsds_text" product="default" msgid="772747677303920132">"Ovaj telefon je ograničen na 4G kada koristite 2 SIM kartice. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="no_5g_in_dsds_text" product="tablet" msgid="4757328474425714624">"Ovaj tablet je ograničen na 4G kada koristite 2 SIM kartice. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="no_5g_in_dsds_text" product="device" msgid="6983783505032683314">"Ovaj uređaj je ograničen na 4G kada koristite 2 SIM kartice. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspenduj izvršenje za keširane aplikacije"</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Dozvoli prekrivanje sadržaja ekrana Podešavanja"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Dozolite aplikacijama koje mogu da se prikazuju preko drugih aplikacija da prekrivaju sadržaj ekrana Podešavanja"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Mediji"</string>
    <string name="media_controls_summary" msgid="3573121049460596520">"Medija plejer u Brzim podešavanjima"</string>
    <string name="media_controls_resume_description" msgid="7702723104730495227">"Prikazuje medija plejer u dužem periodu da bi se lako nastavila reprodukcija"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Sakrij plejer"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Prikaži plejer"</string>
    <string name="media_controls_no_players" msgid="3493023121892175946">"Nije dostupan nijedan plejer"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"mediji"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth će se uključiti"</string>
</resources>
