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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Da"</string>
    <string name="no" msgid="6731231425810196216">"Ne"</string>
    <string name="create" msgid="3578857613172647409">"Ustvari"</string>
    <string name="allow" msgid="3349662621170855910">"Dovoli"</string>
    <string name="deny" msgid="6947806159746484865">"Zavrni"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Neznano"</string>
  <plurals name="show_dev_countdown">
    <item quantity="one" msgid="5295687242294085452">"Št. korakov, ki vas loči od tega, da postanete razvijalec: <xliff:g id="STEP_COUNT">%1$d</xliff:g>."</item>
    <item quantity="other" msgid="6722953419953594148">"Št. korakov, ki vas loči od tega, da postanete razvijalec: <xliff:g id="STEP_COUNT">%1$d</xliff:g>."</item>
  </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Zdaj ste razvijalec."</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Ni treba, ker ste že razvijalec."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Brezžična omrežja"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Povezave"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Naprava"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Osebno"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Dostop"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sistem"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Vklopi radio"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Izklopi radio"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Vklop SMS prek IMS"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Izklop SMS prek IMS"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Vklop registracije IMS"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Izklop registracije IMS"</string>
    <string name="volte_provisioned_flag_on" msgid="6023503159480902956">"Vklop zastavice za omogočeno uporabo storitve VoLTE"</string>
    <string name="volte_provisioned_flag_off" msgid="6168612015904744405">"Izklop zastavice za omogočeno uporabo storitve VoLTE"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Vklopi izpis RAM-a za LTE"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Izklopi izpis RAM-a za LTE"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Prikaži imenik na kartici SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Prikaži številke za zaporo odhodnih klicev"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Prikaži številke za klicanje storitev"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Pridobi seznam PDP"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"V uporabi"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Ne deluje"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Samo klici v sili"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Radio je izklopljen"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Gostovanje"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Ni gostovanja"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Nedejaven"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Zvonjenje"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Klic poteka"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Prekinjena povezava"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Vzpostavljanje povezave"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Povezava je vzpostavljena"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Začasno ustavljeno"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"neznano"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pkts"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajtov"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Izpni pomnilnik USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Izpni kartico SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Izbriši pomnilnik USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Izbriši kartico SD"</string>
    <string name="small_font" msgid="2295331917424072635">"Majhna"</string>
    <string name="medium_font" msgid="2068475425515133701">"Srednja"</string>
    <string name="large_font" msgid="599055175160971446">"Velika"</string>
    <string name="font_size_save" msgid="3450855718056759095">"V redu"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Pomnilnik USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Kartica SD"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"Stanje baterije:"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Priključek za napajanje:"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Lestvica za baterijo:"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Raven napolnjenosti baterije:"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"Ustreznost stanja baterije:"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Tehnologija baterije:"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Napetost baterije:"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Temperatura baterije:"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"°C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Čas od zagona:"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Čas odklenjenega zaslona med napajanjem iz baterije:"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Čas odklenjenega zaslona med polnjenjem:"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Čas vklopa zaslona:"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Neznano"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Polnjenje"</string>
    <string name="battery_info_status_charging_ac" msgid="2909861890674399949">"Polnj. prek iz. toka"</string>
    <string name="battery_info_status_charging_usb" msgid="2207489369680923929">"Polnj. prek USB-ja"</string>
    <string name="battery_info_status_charging_wireless" msgid="3574032603735446573">"Brezžično polnjenje"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Se ne polni"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Se ne polni"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Polna"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Odklopljeno"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"Napajanje"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_wireless" msgid="6819163295739305097">"brezžično"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"Napajanje + USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Neznano"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Neznano"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Dobro"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Pregretje"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Izpraznjena"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Previsoka napetost"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Neznana napaka"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Hladno"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Vidno vsem napravam Bluetooth v bližini (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Vidno vsem napravam Bluetooth v bližini"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Ni vidno drugim napravam Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Vidno samo seznanjenim napravam"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Časovna omejitev vidnosti"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Zakleni glasovno klicanje"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Prepreči uporabo telefona Bluetooth, kadar je zaslon zaklenjen"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Naprave Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Ime naprave"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Nastavitve naprave"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Nastavitve profila"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Ime ni nastavljeno, uporablja se ime računa"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Išči naprave"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Preimenuj to napravo"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Preimenuj"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Želite prekiniti povezavo?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"S tem bo prekinjena povezava z napravo:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="1185354873716211496">"Nimate dovoljenja za spreminjanje nastavitev za Bluetooth."</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je vidna napravam v bližini, ko so odprte nastavitve za Bluetooth."</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Ali želite prekiniti povezavo z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Oddajanje"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Želite onemogočiti profil?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"S tem boste onemogočili:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;From:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_connected" msgid="6038755206916626419">"Povezava je vzpostavljena"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Povezava vzpostavljena (brez telefona)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Povezava vzpostavljena (brez predstavnosti)"</string>
    <string name="bluetooth_connected_no_map" msgid="6504436917057479986">"Povezava vzp. (ni dostopa do sporočil)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Povezava vzpostavljena (brez telefona ali predstavnosti)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Prekinjena povezava"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Prekinjanje povezave ..."</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Vzpostavljanje povezave ..."</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Seznanjanje ..."</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Neimenovana naprava Bluetooth"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Iskanje"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"V bližini ni naprav Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Zahteva za seznanitev Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Zahteva za seznanitev"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Dotaknite se za povezovanje z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Pokaži prejete datoteke"</string>
    <string name="device_picker" msgid="4978696506172252813">"Izberite napravo Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Zahteva za dovoljenje za uporabo funkcije Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="637355677176904990">"Aplikacija želi vklopiti Bluetooth."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Aplikacija želi, da lahko druge naprave Bluetooth vidijo vaš tablični računalnik toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Aplikacija želi, da lahko druge naprave Bluetooth vidijo vaš telefon toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Aplikacija želi omogočiti, da lahko druge naprave Bluetooth vidijo vaš tablični računalnik. To lahko pozneje spremenite v nastavitvah Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Aplikacija želi omogočiti, da lahko druge naprave Bluetooth vidijo vaš telefon. To lahko pozneje spremenite v nastavitvah Bluetooth."</string>
    <string name="bluetooth_ask_start_broadcast" product="default" msgid="3535628155254187911">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti oddajanje Bluetooth za komuniciranje z drugimi napravami v bližini. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default" msgid="8810858601242763295">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti Bluetooth in oddajanje Bluetooth za komuniciranje z drugimi napravami v bližini. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_broadcasting_explaination" product="default" msgid="4249322115655011799">"Ko je ta funkcija vklopljena, lahko telefon komunicira z drugimi napravami v bližini.\n\nOddajanje uporablja signale Bluetooth majhne moči."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Aplikacija želi vklopiti Bluetooth in omogočiti, da lahko druge naprave vidijo vaš tablični računalnik toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Aplikacija želi vklopiti Bluetooth in omogočiti, da lahko druge naprave vidijo vaš telefon toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Aplikacija želi vklopiti Bluetooth in omogočiti, da lahko druge naprave vidijo vaš tablični računalnik. To lahko pozneje spremenite v nastavitvah Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Aplikacija želi vklopiti Bluetooth in omogočiti, da lahko druge naprave vidijo vaš telefon. To lahko pozneje spremenite v nastavitvah Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Vklop Bluetootha…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Izklop Bluetootha…"</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Samodejno poveži"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Zahteva za povezavo Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Dotaknite se za povezavo z napravo »<xliff:g id="DEVICE_NAME">%1$s</xliff:g>E«"</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Se želite povezati z napravo »<xliff:g id="DEVICE_NAME">%1$s</xliff:g>«?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Zahteva za dostop do telefonskega imenika"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s želi dostop do vaših stikov in zgodovine klicev. Želite dovoliti dostop osebi %2$s?"</string>
    <string name="bluetooth_remember_choice" msgid="6198284561603824931">"Ne vprašaj me več"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Ne vprašaj me več"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Zahteva za dostop do sporočil"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s želi dostopati do vaših sporočil. Želite omogočiti dostop za %2$s?"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Datum in čas"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Izberite časovni pas"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Predogled:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Velikost pisave:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Pošlji <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Začni <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Račun:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Strežnik proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Počisti"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Vrata strežnika proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Obidi strežnik proxy pri"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com, mycomp.test.com, localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Ponastavi na privzeto"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Končano"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Gostiteljsko ime strežnika proxy"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Pozor"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"V redu"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Ime gostitelja, ki ste ga vtipkali, ni veljavno."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"Seznam izključitev, ki ste ga vnesli, ni pravilno oblikovan. Domene na seznamu morajo biti ločene z vejico."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Izpolniti morate polje vrat."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Če je polje za gostitelja prazno, mora biti prazno tudi polje za vrata."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Vtipkana številka vrat je neveljavna."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Proxy HTTP lahko uporablja brskalnik, druge aplikacije pa ne."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL datoteke PAC: "</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Lokacija:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"CID v bližini:"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"Podatki o celici:"</string>
    <string name="radio_info_dcrtinfo_label" msgid="6802395441317448068">"Diagnostične informacije:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Podatkovni poskusi:"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"Storitev GPRS:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Gostovanje:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Preusmeritev klica:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"Število ponastavitev PPP od zagona:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"Prekinitev povezave GSM:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Trenutno omrežje:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Uspešne podatkovne operacije:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"Prejeto s protokolom PPP:"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"Storitev GSM:"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Moč signala:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Stanje klica:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"Poslano s protokolom PPP:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Ponastavitve radia:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Čakajoče sporočilo:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Telefonska številka:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Izberite radijsko pasovno širino"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Vrsta omrežja:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Nastavite vrsto prednostnega omrežja:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Preveri dosegljivost naslova IP:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Preveri dosegljivost gostitelja (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"Preizkus odjemalca HTTP:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Zaženi preizkus za preverjanje dosegljivosti (ping)"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Posodobi"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Osveži"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Preklopi preverjanje DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informacije/nastavitve za OEM"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Nastavi frekvenčni pas GSM/UMTS"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Nalaganje seznama frekvenčnih pasov ..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Nastavi"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Ni uspelo"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Uspelo"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Spremembe začnejo veljati ob vnovičnem priklopu kabla USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Omogoči masovni pomnilnik USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Skupno število bajtov:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Pomnilnik USB ni vpet."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Ni kartice SD."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Število razpoložljivih bajtov:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB kot naprav. za množ. shr."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Kartica SD se uporablja kot naprava za množično shranjevanje."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"Zdaj lahko varno odstranite pomnilnik USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"Zdaj lahko varno odstranite kartico SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"Pomnilnik USB je bil odstranjen, ko je bil še v uporabi."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Kartico SD ste odstranili, ko je bila še v uporabi."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Zasedeni bajti:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Iskanje predstavnostnih datotek na pomnilniku USB ..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Iskanje predstavnostih datotek na kartici SD ..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Pomnilnik USB je vpet samo za branje."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Vpeta kartica SD je samo za branje."</string>
    <string name="skip_label" msgid="47510779345218297">"Preskoči"</string>
    <string name="next_label" msgid="4693520878012668114">"Naprej"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Jezik"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Izberite dejavnost"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacije o napravi"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Informacije o bateriji"</string>
    <string name="display_label" msgid="8074070940506840792">"Zaslon"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Podatki o tabličnem računalniku"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacije o telefonu"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Pomnilnik USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Kartica SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Nastavitve strežnika proxy"</string>
    <string name="cancel" msgid="6859253417269739139">"Prekliči"</string>
    <string name="cancel_all_caps" msgid="3183966387632229461">"PREKLIČI"</string>
    <string name="continue_all_caps" msgid="5152713914673789893">"NADALJUJ"</string>
    <string name="okay" msgid="1997666393121016642">"V redu"</string>
    <string name="yes_all_caps" msgid="5454685069075197457">"DA"</string>
    <string name="no_all_caps" msgid="3242375449351298529">"NE"</string>
    <string name="forget" msgid="7267115980248732932">"OPUSTI"</string>
    <string name="settings_label" msgid="1626402585530130914">"Nastavitve"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Nastavitve"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Bližnjica do nastavitev"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Način za letalo"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Več"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Brezžično in omrežja"</string>
    <string name="radio_controls_summary" msgid="2837395036275123133">"Upravljanje Wi-Fi-ja, Bluetootha, načina za letalo, mobilnih omrežij in omrežij VPN"</string>
    <string name="cellular_data_title" msgid="2525947635539415202">"Prenos podatkov v mob. omrež."</string>
    <string name="calls_title" msgid="3544471959217176768">"Klici"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Sporočila SMS"</string>
    <string name="cellular_data_summary" msgid="4575500999626276446">"Dovoli prenos podatkov v mobil. omrežju"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Dovoli prenos podat. med gost."</string>
    <string name="roaming" msgid="3596055926335478572">"Podatkovno gostovanje"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Med gostovanjem vzpostavi povezavo s podatkovnimi storitvami"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Med gostovanjem vzpostavi povezavo s podatkovnimi storitvami"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Podatkovna povezava ni mogoča, ker ste zapustili domače omrežje, podatkovno gostovanje pa je izklopljeno."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Vklopi"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Če dovolite podatkovno gostovanje, so lahko stroški gostovanja visoki."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Če omogočite podatkovno gostovanje, si lahko naprtite velike stroške!\n\nNastavitev vpliva na vse uporabnike v tem tabličnem računalniku."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Če omogočite podatkovno gostovanje, si lahko naprtite velike stroške!\n\nNastavitev vpliva na vse uporabnike v tem telefonu."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Želite dovoliti podatkovno gostovanje?"</string>
    <string name="networks" msgid="6333316876545927039">"Izbira operaterja"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Izbira omrežnega operaterja"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Datum in ura"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Nastavitev datuma in ure"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Nastavi datum, uro, časovni pas in oblike"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Samodejna datum in ura"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Uporabi uro omrežja"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Uporabi uro omrežja"</string>
    <string name="zone_auto" msgid="334783869352026648">"Samodejno nast. čas. pas"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Uporabi časovni pas omrežja"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Uporabi časovni pas omrežja"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24-urna oblika"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Uporabljaj 24-urno obliko"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Čas"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Nastavi uro"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Časovni pas"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Izberite časovni pas"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Datum"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Nastavi datum"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Razvrsti po abecedi"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Razvrsti po časovnem pasu"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Datum"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Ura"</string>
    <string name="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Izboljšano ujemanje obraza"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Preverjanje živosti"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Pri odklepanju zahtevaj pomežik z očmi"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Samodejno zaklepanje"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po stanju pripravljenosti"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po stanju pripravljenosti, razen ko <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> poskrbi, da ostane odklenjen"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Prikaži lastnikove podatke na zaklenjenem zaslonu"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Lastnikovi podatki"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Omogoči pripomočke"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Onemogočil skrbnik"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Vnesite besedilo za prikaz na zaslonu za zaklepanje"</string>
    <string name="show_user_info_on_lockscreen_label" msgid="8408914624925608365">"Pokaži podatke o uporabniku na zaklenjenem zaslonu"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Podatki o uporabniku"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Pokaži podatke o profilu na zaklenjenem zaslonu"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Podatki o profilu"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Računi"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Lokacija"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Računi"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Varnost"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Nastavi Mojo lokacijo, odklepanje zaslona, zaklepanje kartice SIM, zaklepanje shrambe poverilnic"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Nastavitev Moje lokacije, odklepanja zaslona, zaklepanja shrambe poverilnic"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Gesla"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifriranje"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Šifriraj tablični računalnik"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifriraj telefon"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifrirano"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="2876073029767953111">"Šifrirate lahko račune, nastavitve, prenesene aplikacije in njihove podatke, predstavnosti in druge datoteke. Če ste nastavili zaklepanje zaslona (z vzorcem, številsko kodo PIN ali geslom), boste morali po šifriranju tabličnega računalnika ob vsakem vklopu odkleniti zaslon, če boste želeli tablični računalnik dešifrirati. Edini drugi način dešifriranja tabličnega računalnika je, da ga ponastavite na tovarniške nastavitve, s čemer izbrišete vse podatke.\n\nŠifriranje traja najmanj eno uro. Ko začnete šifriranje, naj bo akumulator napolnjen, tablični računalnik pa naj bo med celotnim postopkom priklopljen na električno omrežje. Če postopek prekinete, boste izgubili nekatere ali vse podatke."</string>
    <string name="crypt_keeper_desc" product="default" msgid="5573427498609458721">"Šifrirate lahko račune, nastavitve, prenesene aplikacije in njihove podatke, predstavnosti in druge datoteke. Če ste nastavili zaklepanje zaslona (z vzorcem, številsko kodo PIN ali geslom), boste morali po šifriranju telefona ob vsakem vklopu odkleniti zaslon, če boste želeli telefon dešifrirati. Edini drugi način dešifriranja je, da telefon ponastavite na tovarniške nastavitve, s čemer izbrišete vse podatke.\n\nŠifriranje traja najmanj eno uro. Ko začnete šifriranje, naj bo akumulator napolnjen, telefon pa naj bo med celotnim postopkom priklopljen na električno omrežje. Če postopek prekinete, boste izgubili nekatere ali vse podatke."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Šifriraj tablični računalnik"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Šifriraj telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Napolnite baterijo in poskusite znova."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Priključite polnilnik in poskusite znova."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Ni kode PIN ali gesla za zaklepanje zaslona"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Preden lahko začnete s šifriranjem, morate nastaviti kodo PIN ali geslo za zaklepanje zaslona."</string>
    <string name="crypt_keeper_confirm_encrypt" msgid="736289627726831055">"Če želite potrditi šifriranje naprave, morate narisati vzorec za odklepanje."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Želite šifrirati?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Šifriranja ne morete razveljaviti ali prekiniti, ker lahko izgubite podatke. Šifriranje traja eno uro ali več in v tem času se bo tablični računalnik večkrat znova zagnal."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="5682944380460921880">"Šifriranja ne morete razveljaviti ali prekiniti, ker lahko izgubite podatke. Šifriranje traja eno uro ali več in v tem času se bo telefon večkrat znova zagnal."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Šifriranje"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Počakajte, tablični računalnik se šifrira. Dokončano: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Počakajte, telefon se šifrira. Dokončano: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Počakajte, poteka šifriranje tabličnega računalnika. Preostane še: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Počakajte, poteka šifriranje telefona. Preostane še: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Če želite odkleniti tablični računalnik, ga izklopite in nato vklopite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Če želite odkleniti telefon, ga izklopite in nato vklopite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Opozorilo: Podatki v napravi bodo izbrisani po še toliko neuspešnih poskusih odklepanja: <xliff:g id="COUNT">^1</xliff:g>."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Vnesite geslo"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Šifriranje ni uspelo"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Šifriranje je bilo prekinjeno in ga ni mogoče končati, zato podatki v tabličnem računalniku niso več dostopni. \n\nČe želite tablični računalnik spet uporabljati, ga morate ponastaviti na tovarniške nastavitve. Ko ga po ponastavitvi spet nastavite, boste lahko obnovili vse podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3083477162766772532">"Šifriranje je bilo prekinjeno in ga ni mogoče končati, zato podatki v telefonu niso več dostopni. \n\nČe želite telefon ponovno uporabljati, ga morate ponastaviti na tovarniške nastavitve. Ko ga po ponastavitvi ponovno nastavite, boste lahko obnovili vse podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dešifriranje ni uspelo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="3775740783651700375">"Vnesli ste pravilno geslo, vendar so podatki žal poškodovani. \n\nČe želite nadaljevati z uporabo tabličnega računalnika, ga morate ponastaviti na tovarniške nastavitve. Ko boste po ponastavitvi nastavljali tablični računalnik, boste lahko obnovili morebitne podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="6898436151871328007">"Vnesli ste pravilno geslo, vendar so podatki žal poškodovani. \n\nČe želite nadaljevati z uporabo telefona, ga morate ponastaviti na tovarniške nastavitve. Ko boste po ponastavitvi nastavljali telefon, boste lahko obnovili morebitne podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Preklopite način vnosa"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Izberite zakl. zaslona"</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Izberite varnostno zaklepanje"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zaklepanje zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Sprememba zakl. zasl."</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Spremeni ali onemogoči vzorec, kodo PIN ali varnost gesla"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Izberite način zaklepanja zaslona"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Kako želite odkleniti, če vas s funkcijo odklepanja z obrazom ni mogoče prepoznati?"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Brez"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Vlečenje"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Brez varnosti"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Odklepanje z obrazom"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Nizka varnost, poskusno"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Vzorec"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Srednja varnost"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"Koda PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Srednja do visoka varnost"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Geslo"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Visoka varnost"</string>
    <string name="unlock_disable_frp_warning_content" msgid="7070131836291098244">"Funkcije za zaščito naprave ne bodo več delovale."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Onem. skrbnik, šifr. pravilnik shr. poverilnic"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Brez"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Vlečenje"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Odklepanje z obrazom"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Vzorec"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"Koda PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Geslo"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Izklopi zaklepanje zaslona"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Odstrani vzorec za odklepanje"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Odstrani kodo PIN za odklepanje"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Odstrani geslo za odklepanje"</string>
    <string name="unlock_disable_lock_unknown_summary" msgid="8688498722601653961">"Odstrani zaklepanje zaslona"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Spremeni vzorec za odklepanje"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Spremeni kodo PIN za odklepanje"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Spremeni geslo za odklepanje"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Geslo mora vsebovati vsaj %d znakov"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"Koda PIN mora biti vsaj %d-mestna"</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Ko končate, se dotaknite »Naprej«"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Naprej"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Geslo mora imeti manj kot toliko znakov: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"PIN mora imeti manj kot toliko številk: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"PIN lahko vsebuje samo števke od 0 do 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"Skrbnik naprave ne dovoli uporabe nedavne kode PIN."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Geslo ima neveljaven znak."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Geslo mora vsebovati vsaj eno črko."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Geslo mora imeti vsaj eno števko."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Geslo mora imeti vsaj en simbol."</string>
  <plurals name="lockpassword_password_requires_letters">
    <item quantity="one" msgid="3063853802158131458">"Geslo mora imeti vsaj eno črko."</item>
    <item quantity="other" msgid="8186027808415585970">"Geslo mora imeti vsaj toliko črk: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Geslo mora imeti vsaj eno malo črko."</item>
    <item quantity="other" msgid="2693910942679679225">"Geslo mora imeti vsaj toliko malih črk: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Geslo mora imeti vsaj eno veliko črko."</item>
    <item quantity="other" msgid="3030801209112209245">"Geslo mora imeti vsaj toliko velikih črk: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Geslo mora imeti vsaj eno številko."</item>
    <item quantity="other" msgid="4703982391407595924">"Geslo mora imeti vsaj toliko številk: %d."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Geslo mora imeti vsaj en posebni znak."</item>
    <item quantity="other" msgid="1221290525051187757">"Geslo mora imeti vsaj toliko posebnih znakov: %d"</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Geslo mora imeti vsaj en znak, ki ni črka."</item>
    <item quantity="other" msgid="3952508584649046404">"Geslo mora imeti vsaj toliko znakov, ki niso črke: %d."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Skrbnik naprave ne dovoli uporabe nedavnega gesla."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="6830610582179569631">"Naraščajoč, padajoč ali ponavljajoč se niz števk je prepovedan"</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"V redu"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Prekliči"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Prekliči"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Naprej"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Namestitev je končana."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Skrbništvo naprave"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Skrbniki naprav"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Ogled ali izklop skrbnikov naprave"</string>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Posredniki zaupanja"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Če želite uporabljati, najprej nastavite zaklepanje zaslona"</string>
    <string name="manage_trust_agents_summary" msgid="6804319935640148441">"Ogled ali deaktiviranje posrednikov zaupanja"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Vklopi Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Upravljanje povezav, nastavitev imena naprave in vidnosti"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Zahteva za seznanitev Bluetooth"</string>
    <string name="bluetooth_enter_pin_msg" msgid="4954085254142996877">"Naprava"</string>
    <string name="bluetooth_pairing_key_msg" msgid="333005542843637754">"Koda za seznanjanje"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Vnesite kodo za seznanjanje in nato pritisnite Return ali Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"PIN vsebuje črke ali simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Običajno 0000 ali 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Ta PIN boste morda morali vnesti tudi v drugi napravi."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Geslo boste morda morali vnesti tudi v drugi napravi."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Če želite seznaniti z napravo:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Prikazano mora biti to geslo:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Od:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Ali se želite povezati s to napravo?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Če želite vzpostaviti povezavo z napravo:<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>V njej vnesite:<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> in pritisnite Return ali Enter."</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Seznani"</string>
    <string name="bluetooth_pairing_accept_all_caps" msgid="6061699265220789149">"SEZNANI"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Prekliči"</string>
    <string name="bluetooth_pairing_will_share_phonebook" msgid="4982239145676394429">"Seznanjanje pri vzpostavljeni povezavi omogoči dostop do vaših stikov in zgodovine klicev."</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Ni bilo mogoče vzpostaviti povezave z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Zaradi nepravilne kode PIN ali gesla ni mogoče vzpostaviti povezave z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ni mogoče vzpostaviti povezave."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je zavrnila seznanitev."</string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Povezave z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ni bilo mogoče vzpostaviti."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Išči naprave"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Osveži"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Iskanje ..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Nastavitve naprave"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Seznanjena naprava"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Ime"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Internetna povezava"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Tipkovnica"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Stiki in zgodovina klicev"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Želite opraviti seznanitev s to napravo?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Želite dati telef. imenik v skupno rabo?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi dostopati do vaših stikov in zgodovine klicev."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> se želi seznaniti prek Bluetootha. Ko bo povezana, bo imela dostop do vaših stikov in zgodovine klicev."</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Povezane naprave"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Razpoložljive naprave"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nobena naprava ni na voljo"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Vzpostavi povezavo"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Prekini povezavo"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Seznanitev in povezava"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Prekliči seznanitev"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Prekini povezavo in prekliči seznanitev"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Možnosti …"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Dodatno"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Dodatne nast. za Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Ko je Bluetooth vklopljen, lahko vaša naprava komunicira z drugimi napravami Bluetooth v bližini."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Vzpostavi povezavo z ..."</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Zvok predstavnosti"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Zvok telefona"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Prenos datoteke"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Vnosna naprava"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Internetni dostop"</string>
    <string name="bluetooth_profile_pbap" msgid="5372051906968576809">"Dajanje stikov v skupno rabo"</string>
    <string name="bluetooth_profile_pbap_summary" msgid="6605229608108852198">"Uporabi za dajanje stikov v skupno rabo"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Skupna raba internetne povezave"</string>
    <string name="bluetooth_profile_map" msgid="5465271250454324383">"Dostop do sporočil"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Povezava med napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> in zvokom nosilca podatkov bo prekinjena."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Povezava med napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> in prostoročnim zvokom bo prekinjena."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Povezava med napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> in vnosno napravo bo prekinjena."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Internetni dostop prek naprave <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo prekinjen."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="5455448395850929200">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo izključena iz skupne rabe internetne povezave tega tabličnega računalnika."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5266851881175033601">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo izključena iz skupne rabe internetne povezave tega telefona."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Seznanjena naprava Bluetooth"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Vzpostavi povezavo"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Vzpostavi povezavo z napravo Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Uporaba za"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Preimenuj"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Dovoli dohodne prenose datotek"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"Povezan s profilom za predstavnostni zvok"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Povezava s profilom za zvok telefona vzpostavljena"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Povezava s strežnikom za prenos datotek je vzpostavljena"</string>
    <string name="bluetooth_map_profile_summary_connected" msgid="8191407438851351713">"Povezava je vzpostavljena z zemljevidom"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Povezava s strežnikom za prenos datotek ni vzpostavljena"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Povezava z vnosno napravo je vzpostavljena"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Povezava z napravo za internetni dostop"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Skupna raba lok. internetne povezave z napravo"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Uporabi za zvok predstavnosti"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Uporabi za zvok telefona"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Uporabi za prenos datotek"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Uporabi za vnos"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Uporabi za dostop do interneta"</string>
    <string name="bluetooth_map_profile_summary_use_for" msgid="5154200119919927434">"Uporabi za zemljevid"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Nastavitve stojala"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Uporabi stojalo za zvok"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Kot zvočnik"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Za glasbo in predstavnost"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapomni si nastavitve"</string>
    <string name="wifi_assistant_title" msgid="2553267316621598101">"Pomočnik za Wi‑Fi"</string>
    <string name="connected_via_wfa" msgid="3805736726317410714">"Povezava vzpostavljena prek pomočnika za Wi-Fi"</string>
    <string name="wifi_display_settings_title" msgid="2925465988657380522">"Zaslon za predvajanje"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Omogočanje brezžičnega zaslona"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"V bližini ni naprav."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Povezovanje"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Povezane"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"V uporabi"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Ni na voljo"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Nastavitve naprave"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Možnosti prikaza brezžičnih naprav"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Pozabi"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Končano"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Ime"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Dovoli izmenjavo podatkov, ko se tablični računalnik dotakne druge naprave"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Dovoli izmenjavo podatkov, ko se telefon dotakne druge naprave"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Pripravljen za prenos vsebine aplikacije prek NFC"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Izklopljeno"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Ni na voljo, ker je NFC izklopljen"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Če je ta funkcija vklopljena, lahko vsebino iz aplikacije prenesete v drugo napravo, ki podpira NFC, tako da napravi približate. Prenesete lahko na primer strani brskalnika, videoposnetke v YouTubu, stike iz aplikacije Ljudje in drugo.\n\nPribližajte napravi (običajno s hrbtno stranjo) in se dotaknite zaslona. Kaj se prenese, je odvisno od aplikacije."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Odkrivanje omrežnih storitev"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Dovoli, da aplikacije v drugih napravah odkrivajo aplikacije v tej napravi"</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi‑Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Vklopi Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi‑Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Nastavitve za Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi‑Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Nastavi in upravljaj brezžične dostopne točke"</string>
    <string name="wifi_setup_wizard_title" msgid="7873622558088429710">"Izberi omrežje Wi‑Fi"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Izberi Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Vklapljanje povezave Wi‑Fi …"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Izklapljanje povezave Wi‑Fi …"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Napaka"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"V načinu za letalo"</string>
    <string name="wifi_fail_to_scan" msgid="1265540342578081461">"Ni mogoče iskati omrežij"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Obveščanje o omrežjih"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3716818008370391253">"Obveščanje, ko je na voljo javno omrežje"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Izogni se slabim povezavam"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7843672905900544785">"Omrežje Wi-Fi uporabi samo, če je na voljo dobra internetna povezava"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"Uporaba samo omrežij z dobro internetno povezavo"</string>
    <string name="wifi_scan_always_available" msgid="3470564139944368030">"Iskanje vedno na voljo"</string>
    <string name="wifi_scan_always_available_title" msgid="1518769058260729007">"Vedno dovoli iskanje"</string>
    <string name="wifi_scan_always_available_summary" msgid="5442775583708315387">"Googlova lokacijska storitev in druge aplikacije naj poiščejo omrežja, tudi če je Wi-Fi izklopljen"</string>
    <string name="wifi_automatically_connect_title" msgid="7950640291510621742">"Samodejno uporabi odprto omrežje Wi‑Fi"</string>
    <string name="wifi_automatically_connect_summary" msgid="6722194413023965902">"Naj pomočnik za Wi-Fi samodejno vzpostavi povezavo z odprtimi omrežji visoke kakovosti"</string>
    <string name="wifi_select_assistant_dialog_title" msgid="4014645210955009439">"Izbira pomočnika"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Namestitev potrdil"</string>
    <string name="wifi_scan_notify_text_location_on" msgid="8135076005488914200">"Za večjo natančnost in druge namene dovolite Googlovi lokacijski storitvi in drugim aplikacijam, da iščejo omrežja Wi-Fi v bližini, tudi če je Wi-Fi izklopljen. Če tega ne želite, odprite Dodatno &gt; Iskanje vedno na voljo."</string>
    <string name="wifi_scan_notify_text_location_off" msgid="6323983741393280935">"Aplikacije lahko iščejo omrežja Wi-Fi v bližini, tudi če je Wi-Fi izklopljen. Če tega ne želite, odprite Dodatno &gt; Iskanje vedno na voljo."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="5340097010842405981">"Tega ne kaži več"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Ohrani povezavo Wi-Fi med spanjem"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi-Fi vklop. v stanju priprav."</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Težava pri spreminjanju nastavitve"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Izboljšanje učinkovitosti"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizacija Wi-Fi-ja"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Zmanjšanje porabe energije, ko je vklopljen Wi-Fi"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Omejitev porabe akum. za Wi‑Fi"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Dodaj omrežje"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Omrežja Wi-Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Gumb za WPS"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Več možnosti"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Vnos kode PIN za WPS"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Išči"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Dodatno"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Vzpostavi povezavo z omrežjem"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Zapomni si omrežje"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Pozabi omrežje"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Spremeni omrežje"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Zapisovanje na oznako NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Za prikaz razpoložljivih omrežij vklopite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Iskanje omrežij Wi-Fi …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="8280257225419947565">"Nimate dovoljenja za spreminjanje omrežja Wi‑Fi."</string>
    <string name="wifi_other_network" msgid="1484433183857764750">"Dodajanje drugega omrežja"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Več"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Samodej. nastavitev (WPS)"</string>
    <string name="wifi_required_info_text" msgid="7442238187557620087">"Če želite dokončati namestitev, mora imeti tablični računalnik dostop do omrežja Wi-Fi. Po namestitvi lahko preklapljate med prenosom podatkov v mobilnem omrežju in omrežjem Wi-Fi."</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Dodatne možnosti"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Wi‑Fi Protected Setup"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Zagon nastavitve WPS ..."</string>
    <string name="wifi_wps_onstart_pbc" msgid="5940801028985255304">"Pritisnite gumb »Wi‑Fi Protected Setup« na usmerjevalniku. Morda se imenuje »WPS« ali vsebuje ta simbol:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Vnesite PIN <xliff:g id="NUMBER">%1$s</xliff:g> za usmerjevalnik Wi‑Fi. Namestitev lahko traja do dve minuti."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"Nastavitev WPS je uspela. Povezovanje z omrežjem ..."</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Vzpostavljena povezava z omrežjem Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"Nastavitev WPS že poteka in lahko traja največ dve minuti"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"Nastavitev WPS ni uspela. Poskusite znova čez nekaj minut."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Varnostna nastavitev brezžičnega usmerjevalnika (WEP) ni podprta"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Varnostna nastavitev brezžičnega usmerjevalnika (TKIP) ni podprta"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Preverjanje pristnosti ni uspelo. Poskusite znova."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Zaznana je druga seja WPS. Poskusite znova čez nekaj minut."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Ime omrežja"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Vnesite SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Varnost"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Moč signala"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Stanje"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Hitrost povezave"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekvenca"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Naslov IP"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Način EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Preverjanje pristnosti v fazi 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Overjeno potrdilo"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Uporabniško potrdilo"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identiteta"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonimna identiteta"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Geslo"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Pokaži geslo"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Nastavitve naslova IP"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nespremenjeno)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(ni navedeno)"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"Shranjeno"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Onemogočeno"</string>
    <string name="wifi_disabled_network_failure" msgid="2364951338436007124">"Konfiguracija IP-ja ni uspela"</string>
    <string name="wifi_disabled_wifi_failure" msgid="3081668066612876581">"Povezava prek Wi-Fi-ja ni uspela"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Težava s preverjanjem pristnosti"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Ni v obsegu"</string>
    <string name="wifi_no_internet" msgid="9151470775868728896">"Ni zaznanega dostopa do interneta; samodejna vnovična vzpostavitev povezave se ne bo izvedla."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS je na voljo"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS je na voljo)"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Vnesite geslo za omrežje"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Brez"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Za izboljšanje natančnosti lokacijskih podatkov in druge namene želi <xliff:g id="APP_NAME">%1$s</xliff:g> vklopiti iskanje omrežij, tudi ko je Wi-Fi izklopljen.\n\nŽelite to dovoliti vsem aplikacijam, ki želijo iskati omrežja?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Če želite to možnost izklopiti, v meniju z dodatnimi elementi odprite »Dodatno«."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Dovoli"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Zavrni"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Ali se želite prijaviti, da se lahko povežete?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> zahteva spletno prijavo pred povezavo v omrežje."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"POVEŽI"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Vzpostavi povezavo"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Vzpostavljanje povezave z omrežjem ni uspelo"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Pozabi"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Pozabljanje omrežja ni uspelo"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Shrani"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Shranjevanje omrežja ni uspelo"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Prekliči"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Kljub temu preskoči"</string>
    <string name="wifi_dont_skip" msgid="7350341524881124808">"Ne preskoči"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="6761689889733331124">"OPOZORILO: Če preskočite povezavo Wi‑Fi, bo tablični računalnik za začetne prenose in posodobitve uporabljal prenos podatkov v mobilnem omrežju. Če se želite izogniti morebitnim stroškom za prenos podatkov, se povežite v omrežje Wi-Fi."</string>
    <string name="wifi_skipped_message" product="device" msgid="1385490367826852775">"OPOZORILO: Če preskočite povezavo Wi‑Fi, bo naprava za začetne prenose in posodobitve uporabljala prenos podatkov v mobilnem omrežju. Če se želite izogniti morebitnim stroškom za prenos podatkov, se povežite v omrežje Wi-Fi."</string>
    <string name="wifi_skipped_message" product="default" msgid="6084295135297772350">"OPOZORILO: Če preskočite povezavo Wi‑Fi, bo telefon za začetne prenose in posodobitve uporabljal prenos podatkov v mobilnem omrežju. Če se želite izogniti morebitnim stroškom za prenos podatkov, se povežite v omrežje Wi-Fi."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="5872240361944591105">"Če preskočite Wi‑Fi:\n\nv tabličnem računalniku ne bo na voljo internetna povezava.\n\nDokler ne vzpostavite internetne povezave, ne boste prejemali posodobitev programske opreme.\n\nTrenutno ni mogoče aktivirati zaščitnih funkcij naprave."</string>
    <string name="wifi_and_mobile_skipped_message" product="device" msgid="1013689568018268332">"Če preskočite Wi‑Fi:\n\nv napravi ne bo na voljo internetna povezava.\n\nDokler ne vzpostavite internetne povezave, ne boste prejemali posodobitev programske opreme.\n\nTrenutno ni mogoče aktivirati zaščitnih funkcij naprave."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="5245835374169369770">"Če preskočite Wi‑Fi:\n\nv telefonu ne bo na voljo internetna povezava.\n\nDokler ne vzpostavite internetne povezave, ne boste prejemali posodobitev programske opreme.\n\nTrenutno ni mogoče aktivirati zaščitnih funkcij naprave."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Tablični računalnik se ni mogel povezati v to omrežje Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="device" msgid="8870885845666880869">"Naprava se ni mogla povezati v to omrežje Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefon se ni mogel povezati v to omrežje Wi-Fi."</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Shranjena omrežja"</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Dodatne nastavitve za Wi‑Fi"</string>
    <string name="wifi_setting_frequency_band_title" msgid="3655327399028584656">"Frekvenčni pas za Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Določite frekvenčni obseg delovanja"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Težava pri nastavitvi frekvenčnega pasu."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Naslov MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Naslov IP"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Shranjena omrežja"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Nastavitve nasl. IP"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Shrani"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Prekliči"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Vnesite veljaven naslov IP."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Vnesite veljaven naslov prehoda."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Vnesite veljaven naslov DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Vnesite predpono omrežja, dolgo med 0 in 32 znaki."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Prehod"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Dolžina predpone omrežja"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Podatki o napravi"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Zapomni si to povezavo"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Išči naprave"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Iskanje …"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Preimenovanje naprave"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Enakovredne naprave"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Shranjene skupine"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Povezava ni mogoča."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Naprave ni bilo mogoče preimenovati."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Želite prekiniti povezavo?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Če prekinete, se prekine povezava z napravo <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Če prekinete povezavo, bo prekinjena povezava z napravo <xliff:g id="PEER_NAME">%1$s</xliff:g> in še toliko drugimi: <xliff:g id="PEER_COUNT">%2$s</xliff:g>."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Želite preklicati povabilo?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Ali želite preklicati povabilo za povezavo z napravo <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Želite pozabiti to skupino?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Prenosna dostopna točka Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Dostopna točka Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="3800646230853724318">"Uporaba mobil. povezave za omrežje Wi‑Fi"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Vklop dostopne točke  ..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Izklop dostopne točke ..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Prenosna dostopna točka <xliff:g id="NETWORK_SSID">%1$s</xliff:g> dejavna"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Napaka prenosne dostopne točke Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Nastavitev dostopne točke Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Nastavitev dostopne toč. Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5618031116920832182">"Pren. dos. toč. Wi-Fi AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"Prenosna dostopna točka Wi-Fi <xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g>"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Nastavitev klicanja"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="8149690312199253909">"Način klicanja prek Wi-Fi-ja"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="2124257075906188844">"Prednostno – Wi-Fi"</item>
    <item msgid="5267397515594230396">"Prednostno – mobilno omrežje"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values">
    <item msgid="4799585830102342375">"2"</item>
    <item msgid="1171822231056612021">"1"</item>
  </string-array>
    <string name="wifi_calling_off_explanation" msgid="4124926334215228094">"Ko je vklopljeno klicanje prek omrežja Wi-Fi, lahko telefon preusmeri klice prek omrežij Wi-Fi ali omrežja operaterja na podlagi vaše nastavitve in moči signala. Pred vklopom te funkcije pri operaterju preverite cene in druge podrobnosti."</string>
    <string name="home_settings" msgid="212375129455718176">"Začetna stran"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Zaslon"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvok"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Glasnost"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Glasbeni učinki"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Glasnost zvonjenja"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibriraj v tihem načinu"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Privzeti zvok obvestila"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Zvonjenje"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Obvestilo"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Za obvestila uporabljaj glasnost dohodnih klicev"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Ne podpira delovnih profilov"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Privzeti zvok obvestila"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Predstavnost"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Nastavi glasnost za glasbo in video"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarm"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Zvočne nastavitve za priklopljeno stojalo"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Zvok številčnice"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Zvoki dotikov"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvoki zaklepanja zaslona"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Vibrira na dotik"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Zmanjšanje zunanjih zvokov"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Glasba, videoposnetki, igre in druge predstavnosti"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Zvonjenje in obvestila"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Obvestila"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmi"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Izklop zvonjenja in obvestil"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Izklop glasbe in drugih medijev"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Izklop zvoka obvestil"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Izklop alarmov"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Stojalo"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Nastavitvebn stojala"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Zvok"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Nastavitve za priklopljeno namizno stojalo"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Nastavitve za priklopljeno stojalo za avto"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablični računalnik ni v stojalu"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon ni nameščen v stojalu"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Nastavitve za priklopljeno stojalo"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Stojala ni mogoče najti"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Preden nastavite zvok, mora biti tablični računalnik v stojalu."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Preden nastavite zvok, mora biti telefon v stojalu."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvok ob vstavitvi v stojalo"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Predvajaj zvok med vstavljanjem tabličnega računalnika v stojalo ali odstranjevanjem iz njega"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Predvajaj zvok pri vstavitvi telefona v stojalo ali odstranitvi iz njega"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"Ne predvajaj zvoka med vstavljanjem tabličnega računalnika v stojalo ali odstranjevanjem iz njega"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"Ne predvajaj zvoka pri vstavitvi telefona v stojalo ali odstranitvi iz njega"</string>
    <string name="account_settings" msgid="6403589284618783461">"Računi"</string>
    <string name="category_personal" msgid="1299663247844969448">"Osebno"</string>
    <string name="category_work" msgid="8699184680584175622">"Služba"</string>
    <string name="search_settings" msgid="1910951467596035063">"Iskanje"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Upravljaj nastavitve iskanja in zgodovine"</string>
    <string name="display_settings" msgid="7965901687241669598">"Prikaz"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Samodejno zasukaj zaslon"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Samodejno spremeni usmerjenost ob zasuku tabličnega računalnika"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Samodejno preklopi usmeritev ob zasuku telefona"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Samodejno spremeni usmerjenost ob zasuku tabličnega računalnika"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Samodejno preklopi usmeritev ob zasuku telefona"</string>
    <string name="brightness" msgid="8480105032417444275">"Raven svetlosti"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Svetlost"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Prilagoditev svetlosti zaslona"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Prilagodljiva svetlost"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Optimiziranje ravni svetlosti glede na razpoložljivo svetlobo"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Stanje pripravljenosti"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Zaslon se izklopi"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nedejavnosti"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Ozadje"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Izberite ozadje iz"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Sanjarjenje"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"V stojalu ali v stanju pripravljenosti in med polnjenjem"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Eno ali drugo"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Med napajanjem"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"V stojalu"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Izklopljeno"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Če želite nadzorovati, kaj se dogaja, ko je telefon v stojalu in/ali v stanju pripravljenosti, vklopite »Sanjarjenje«."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Kdaj sanjariti"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Začnite zdaj"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Nastavitve"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Samodejna svetlost"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Preklop iz stanja pripravlj. z dviganjem"</string>
    <string name="doze_title" msgid="2259176504273878294">"Prikaz na podlagi okolja"</string>
    <string name="doze_summary" msgid="7128970177894383698">"Preklop zaslona iz stanja pripravljenosti, ko primete napravo ali prejmete obvestila"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Velikost pisave"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Velikost pisave"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Nastavitve zaklepanja kartice SIM"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Nastavi zaklepanje kartice SIM"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Zaklepanje kartice SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Zakleni kartico SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Zahtevaj PIN za uporabo tabličnega računalnika"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Zahtevaj kodo PIN za uporabo telefona"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Zahtevaj PIN za uporabo tabličnega računalnika"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Zahtevaj kodo PIN za uporabo telefona"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Spremeni kodo PIN kartice SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"Koda PIN za kartico SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zakleni kartico SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Odkleni kartico SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Stara koda PIN za kartico SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nova koda PIN za kartico SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Znova vnesite novi PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Koda PIN za kartico SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Napačen PIN"</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"Kodi PIN se ne ujemata"</string>
    <string name="sim_change_failed" msgid="304964924772218382">"Kode PIN ni mogoče spremeniti.\nKoda PIN je morda napačna."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Sprememba kode PIN za kartico SIM je uspela"</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"Zaklepanja kartice SIM ni mogoče spremeniti.\nMorda je koda PIN napačna."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"V redu"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Prekliči"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Najdenih je bilo več kartic SIM"</string>
    <string name="sim_multi_sims_summary" msgid="7018740080801483990">"Izberite kartico SIM, ki jo želite uporabljati za prenos podatkov v mobilnih omrežjih."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Druga kart. SIM za pren. pod.?"</string>
    <string name="sim_change_data_message" msgid="1313940695939674633">"Želite za prenos podatkov v mobilnih omrežjih uporabiti kartico SIM <xliff:g id="NEW_SIM">%1$s</xliff:g> namesto kartice SIM <xliff:g id="OLD_SIM">%2$s</xliff:g>?"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Želite sprem. pred. kart. SIM?"</string>
    <string name="sim_preferred_message" msgid="301251431163650167">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je edina kartica SIM v napravi. Želite uporabljati to kartico SIM za prenos podatkov v mobilnih omrežjih, klice in sporočila SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Napačna koda PIN kartice SIM. Zdaj se boste morali za odklenitev naprave obrniti na operaterja."</string>
  <plurals name="wrong_pin_code">
    <item quantity="one" msgid="4840607930166101114">"Napačna koda PIN kartice SIM. Na voljo imate še <xliff:g id="NUMBER">%d</xliff:g> poskus. Potem se boste morali za odklenitev naprave obrniti na operaterja."</item>
    <item quantity="other" msgid="77103619544346451">"Napačna koda PIN kartice SIM. Poskusite lahko še <xliff:g id="NUMBER">%d</xliff:g>-krat."</item>
  </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Postopek za odklepanje s kodo PIN kartice SIM ni uspel."</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Stanje tabličnega računalnika"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Stanje telefona"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Sistemske posodobitve"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Različica sistema Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Številka modela"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID opreme"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Različica radijske programske opreme"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Različica jedra"</string>
    <string name="build_number" msgid="3075795840572241758">"Delovna različica"</string>
    <string name="selinux_status" msgid="6212165375172061672">"Stanje za SELinux"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Ni na voljo"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Stanje"</string>
    <string name="device_status" msgid="607405385799807324">"Stanje"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Stanje baterije in omrežja ter drugi podatki"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefonska številka, signal itn."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Pomnilnik"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Nastavitve pomnilnika"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Izpni pomnilnik USB, prikaži razpoložljiv pomnilnik"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Izpenjanje kartice SD, prikaz razpoložljivega pomnilnika"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Moja telefonska številka"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Različica seznama prednostnih omrežij za gostovanje"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="952552009117455166">"Vrsta mobilnega omrežja"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Podatki operaterja"</string>
    <string name="status_data_state" msgid="4578972321533789767">"Stanje mobilnega omrežja"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stanje storitve"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Moč signala"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Gostovanje"</string>
    <string name="status_operator" msgid="2274875196954742087">"Omrežje"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Naslov MAC vmesnika Wi‑Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Naslov Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Serijska številka"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Ni na voljo"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Čas delovanja"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Čas delovanja"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Notranji pomnilnik"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Pomnilnik USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Kartica SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"Na voljo"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Na voljo (samo za branje)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Skupno prostora"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Izračunavanje ..."</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Aplikacije (podatki o aplik. in medijska vsebina)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Predstavnost"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Prenosi"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Slike, videoposnetki"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Zvok (glasba, melodije zvonjenja, podcasti ipd.)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Razno"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Predpomnjeni podatki"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Izpni skupno shrambo"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Izpni kartico SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Izpni notranji pomnilnik USB"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Izpni kartico SD, da jo lahko varno odstranim"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Vstavite pomnilnik USB za vpenjanje"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Vstavite kartico SD, da bo vpeta"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Vpni pomnilnik USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Vpni kartico SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Izbriši pomnilnik USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Izbriši kartico SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Izbriše vse podatke na notranjem pomnilniku USB, na primer glasbo ali fotografije"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Izbriše vse podatke na kartici SD, na primer glasbo ali fotografije"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Želite počistiti predpomnjene podatke?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Počistili boste predpomnjene pod. vseh aplikacij."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funkcija MTP ali PTP je aktivna"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Želite izpeti pomnilnik USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Želite izpeti kartico SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Če izpnete pomnilnik USB, bodo nekatere aplikacije, ki jih uporabljate, nehale delovati in ne bodo na voljo, dokler pomnilnika USB spet ne vpnete."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Če izpnete kartico SD, se bodo nekatere aplikacije, ki jih uporabljate, ustavile in morda ne bodo na voljo, dokler znova ne vpnete kartice SD."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="4346280469528260684">"Pomnilnika USB ni bilo mogoče izpeti. Poskusite znova pozneje."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"Kartice SD ni mogoče izpeti. Poskusite znova pozneje."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Pomnilnik USB bo izpet."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Kartica SD bo izpeta."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Izpenjanje"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Izpenjanje poteka"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Prostor za shranjevanje bo pošel"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Nekatere sistemske funkcije, na primer sinhronizacija, morda ne delujejo pravilno. Poskusite sprostiti nekaj prostora tako, da zbrišete ali odpnete elemente, kot so aplikacije ali medijska vsebina."</string>
    <string name="storage_menu_usb" msgid="5708207885333243384">"Povezava USB z računalnikom"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Povezava USB z računalnikom"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Vzpostavi povezavo kot"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Predstavnostna naprava (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"V sistemu Windows lahko prenašate predstavnostne datoteke ali v računalniku Mac uporabite Android File Transfer (glejte www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Fotoaparat (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"Omogoča prenos fotografij s programsko opremo fotoaparata in prenos datotek v računalnikih, ki ne podpirajo protokola MTP"</string>
    <string name="usb_label_installer_cd" msgid="4331173824920630215">"Namestitev orodij za prenos datotek"</string>
    <string name="storage_other_users" msgid="808708845102611856">"Drugi uporabniki"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Stanje baterije"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Raven napolnjenosti baterije"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN-ji"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Uredi dostopno točko"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Ni nastavljeno"</string>
    <string name="apn_name" msgid="4115580098369824123">"Ime"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Strežnik proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Vrata"</string>
    <string name="apn_user" msgid="455637547356117761">"Uporabniško ime"</string>
    <string name="apn_password" msgid="5412301994998250968">"Geslo"</string>
    <string name="apn_server" msgid="2436185314756372858">"Strežnik"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"Storitveni center za sporočila MMS"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Strežnik proxy za sporočila MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Vrata MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"Mobilna koda države"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"Koda mobilnega omrežja"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Vrsta preverjanja pristnosti"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Brez"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ali CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Vrsta APN-ja"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokol za gostovanje APN"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Omogoči/onemogoči APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN omogočen"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN onemogočen"</string>
    <string name="bearer" msgid="594270280031923558">"Nosilec"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Vrsta MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Vrednost MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Izbriši APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nov APN"</string>
    <string name="menu_save" msgid="8109345640668285399">"Shrani"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Zavrzi"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Polje z imenom ne sme biti prazno."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"APN ne sme biti prazen."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Polje z mobilno kodo države mora vsebovati 3 števke."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Polje s kodo mobilnega omrežja mora vsebovati 2 ali 3 števke."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Obnavljanje privzetih nastavitev APN-jev"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Ponastavi na privzeto"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Ponastavitev privzetih nastavitev APN-jev končana"</string>
    <string name="device_reset_title" msgid="2384019005638768076">"Ponastavi napravo"</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Ponastavitev na tovarniške nastavitve"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Izbriše vse podatke na tabličnem računalniku"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Izbriše vse podatke iz telefona"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"S tem boste iz "<b>"notranjega pomnilnika"</b>" tabličnega računalnika izbrisali vse podatke:\n\n"<li>"Google Račun"</li>\n<li>"Podatke in nastavitve sistema in aplikacij"</li>\n<li>"Prenesene aplikacije"</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"S tem boste iz "<b>"notranjega pomnilnika"</b>" telefona izbrisali vse podatke:\n\n"<li>"Google Račun"</li>\n<li>"Podatke in nastavitve sistema in aplikacij"</li>\n<li>"Prenesene aplikacije"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Trenutno ste prijavljeni v te račune:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"V napravi so prisotni drugi uporabniki.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Glasba"</li>\n<li>"Fotografije"</li>\n<li>"Drugi uporabniški podatki"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Če želite izbrisati glasbo, slike in druge uporabniške podatke, morate izbrisati "<b>"pomnilnik USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Če želite izbrisati glasbo, slike in druge uporabniške podatke, morate izbrisati "<b>"kartico SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Izbriši pomnilnik USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Izbriši kartico SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Izbriši vse podatke v notranjem pomnilniku USB, na primer glasbo ali fotografije."</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Izbriši vse podatke na kartici SD, na primer glasbo ali fotografije."</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Ponastavi tablični računalnik"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Ponastavi telefon"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Želite izbrisati vse osebne podatke in prenesene aplikacije? Tega dejanja ni mogoče razveljaviti."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Izbriši vse"</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Če želite potrditi ponastavitev na tovarniške nastavitve, morate narisati vzorec za odklepanje."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Ponastavitev ni opravljena, ker storitev System Clear ni na voljo."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Želite ponastaviti?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Ponastavitev na tovarniške nastavitve ni na voljo za tega uporabnika"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Brisanje"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Počakajte ..."</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Izbriši pomnilnik USB"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Izbriši kartico SD"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Izbriše vse podatke na pomnilniku USB"</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Izbriše vse podatke na kartici SD"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Želite izbrisati pomnilnik USB? Izgubili boste "<b>"vse"</b>" podatke, shranjene v njem."</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Želite izbrisati kartico SD? Izgubili boste "<b>"vse"</b>" podatke, shranjene na njej."</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Izbriši pomnilnik USB"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Izbriši kartico SD"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Ali želite izbrisati vse datoteke, shranjene na pomnilniku USB? Dejanja ni mogoče razveljaviti."</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Ali želite izbrisati vse datoteke, shranjene na kartici SD? Dejanja ni mogoče razveljaviti."</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Izbriši vse"</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"Če želite potrditi brisanje pomnilnika USB, morate narisati vzorec za odklepanje."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"Če želite potrditi brisanje kartice SD, morate narisati vzorec za odklepanje."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Nastavitve klicanja"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Nastavite telefonski predal, preusmeritev klicev, čakajoči klic, ID klicatelja"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Internet prek USB-ja"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Prenosna dostopna točka"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Internet prek Bluetootha"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Internet prek mob. napr."</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Modem/prenosna dost. točka"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Internetna povezava prek USB"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"Povezava USB je vzpostavljena, označite za internetno povezavo prek telefona"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Uporablja se internetna povezava prek telefona"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Internetna povezava prek telefona ni mogoča, kadar se uporablja pomnilnik USB"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"Povezava USB ni vzpostavljena"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Za vklop se povežite"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Zaradi povezave USB je prišlo do napake internetne povezave prek telefona"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Internet prek Bluetootha"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Skupna raba internetne povezave tega tabl. računalnika"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Skupna raba internetne povezave tega telefona"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Internetno povezavo tega tabličnega računalnika souporablja ena naprava"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Internetno povezavo tega telefona souporablja ena naprava"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Št. naprav, ki si deli internetno povezavo tega tabličnega računalnika: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Št. naprav, ki si deli internetno povezavo tega telefona: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="1790242032929221788">"Skupna raba internetne povezave naprave <xliff:g id="DEVICE_NAME">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Brez skupne rabe internetne povez. tega tabl. računalnika"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Brez skupne rabe internetne povezave tega telefona"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Ni povezave"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"Internetna povezava ni mogoča z več kot <xliff:g id="MAXCONNECTION">%1$d</xliff:g> naprav."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Internetna povezava z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo prekinjena."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Pomoč"</string>
    <string name="network_settings_title" msgid="4871233236744292831">"Mobilna omrežja"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Naročniški paket za mobilno napravo"</string>
    <string name="sms_application_title" msgid="6134351177937015839">"Privzeta aplikacija za SMS-e"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Ali želite zamenjati aplikacijo za SMS-e?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Ali želite za SMS-e namesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> uporabljati aplikacijo <xliff:g id="NEW_APP">%1$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Ali želite za SMS-e uporabljati aplikacijo <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Želite zamenjati Pomočnika za Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Želite za upravljanje omrežnih povezav namesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> uporabljati aplikacijo <xliff:g id="NEW_APP">%1$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Želite za upravljanje omrežnih povezav uporabljati aplikacijo <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Neznan ponudnik kartice SIM"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"%1$s nima znanega spletnega mesta za omogočanje uporabe"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Vstavite SIM in znova zaženite"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Vzpostavite internetno povezavo"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja lokacija"</string>
    <string name="managed_profile_location_category" msgid="6992546457880004735">"Delovni profil"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Mesto za delovni profil"</string>
    <string name="managed_profile_location_switch_lockdown" msgid="3851708343340350369">"Izklopilo podjetje"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Način"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Visoka natančnost"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Varč. z energijo akumulatorja"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Samo v napravi"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Lokacija je izklopljena"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Nedavne zahteve za lokacijo"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"V zadnjem času ni nobena aplikacija zahtevala lokacijskih podatkov"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Lokacijske storitve"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Visoka poraba akumulatorja"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Nizka poraba akumulatorja"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Način ugotavljanja lokacije"</string>
    <string name="location_mode_high_accuracy_description" msgid="5349014493087338351">"Uporaba GPS-ja, Wi-Fi-ja in mobilnih omrežij za določanje lokacije"</string>
    <string name="location_mode_battery_saving_description" msgid="7581657383062066461">"Uporaba Wi-Fi-ja in mobilnih omrežij za določanje lokacije"</string>
    <string name="location_mode_sensors_only_description" msgid="788127681455735699">"Uporaba GPS-ja za določanje lokacije"</string>
    <string name="location_network_based" msgid="6010456018401296590">"Lokac. z Wi-Fi-jem in mob. om."</string>
    <string name="location_neighborhood_level" msgid="5626515380188353712">"Aplikacijam omogočite hitrejše določanje lokacije z Googlovo storitvijo za določanje lokacije. Anonimni podatki o lokaciji bodo zbrani in poslani Googlu."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Določanje lokacije z Wi‑Fi-jem"</string>
    <string name="location_gps" msgid="8392461023569708478">"Sateliti GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Za določanje lokacije omogočite aplikacijam uporabo GPS-a v tabličnem računalniku"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Za določanje lokacije omogočite aplikacijam uporabo GPS-a v telefonu"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Uporabljaj GPS s pomočjo"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Uporabljaj strežnik za pomoč pri sistemu GPS (ne označite, da zmanjšate uporabo omrežja)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Uporabi strežnik za pomoč pri uporabi sistema GPS (ne označite, da izboljšate delovanje sistema GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Lokacija in Iskanje Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Naj Google uporablja vašo lokacijo za izboljšanje rezultatov iskanja in drugih storitev"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Dostop do moje lokacije"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Aplikacije, ki prosijo za vaše dovoljenje, lahko uporabijo podatke o lokaciji"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Viri lokacije"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"O tabličnem računalniku"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"O telefonu"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Ogled pravnih informacij, stanja, različice programske opreme"</string>
    <string name="legal_information" msgid="5769301644270604095">"Pravne informacije"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Sodelavci"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Zakonsko predpisani podatki"</string>
    <string name="copyright_title" msgid="865906688917260647">"Avtorska pravica"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenca"</string>
    <string name="terms_title" msgid="7697580845616764642">"Določila in pogoji"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Licenca za WebView v sistemu"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Ozadja"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Ponudniki satelitskih posnetkov: \n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Licence za odprto kodo"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Pri nalaganju licenc je prišlo do težave."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Nalaganje …"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informacije o varnosti"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informacije o varnosti"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Nimate podatkovne povezave. Če si želite te podatke ogledati zdaj, odprite %s iz katerega koli računalnika z internetno povezavo."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Nalaganje …"</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Izberite geslo"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Izberite vzorec"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Izberite kodo PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Potrdite geslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potrdite vzorec"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Potrdite kodo PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Gesli se ne ujemata"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"Kodi PIN se ne ujemata"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Izbira načina odklepanja"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Geslo je nastavljeno"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Koda PIN je nastavljena"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Vzorec je nastavljen"</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Varnost zaslona"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Spremeni vzorec za odklepanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Spremeni kodo PIN za odklepanje"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Potrdite shranjeni vzorec"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Poskusite znova:"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Nariši vzorec za odklepanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Če želite pomoč, pritisnite meni."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Ko končate, dvignite prst"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Povežite vsaj toliko pik: <xliff:g id="NUMBER">%d</xliff:g>. Poskusite znova."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Vzorec je shranjen"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Znova narišite vzorec, da ga potrdite"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Novi vzorec za odklepanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Ponovno nariši"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Poskusi znova"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Naprej"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Vzorec za odklepanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Zahtevaj vzorec"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Za odklepanje zaslona je treba narisati vzorec"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Vzorec je viden"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Vibrira na dotik"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Zaklepanje ob vklopu"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Razen ko <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> poskrbi, da ostane odklenjen"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Nastavi vzorec za odklepanje"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Spremeni vzorec za odklepanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kako narisati vzorec za odklepanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Preveč napačnih poskusov!"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Čez <xliff:g id="NUMBER">%d</xliff:g> sekund poskusite znova."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikacija ni nameščena v telefonu."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Upravljaj aplikacije"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Upravljanje in odstranjevanje nameščenih aplikacij"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Aplikacije"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Upravljanje aplikacij, nastavljanje bližnjic za hiter zagon"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Nastavitve aplikacij"</string>
    <string name="install_applications" msgid="4872012136210802181">"Neznani viri"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Dovoli vse vire aplikacij"</string>
    <string name="install_unknown_applications_title" msgid="663831043139080992">"Omogoča nameščanje aplikacij iz virov, ki niso Google Play"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Dovoli namestitev aplikacij iz neznanih virov"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Aplikacije iz neznanih virov lažje napadejo tablični računalnik in osebne podatke. Strinjate se, da ste za morebitno škodo, nastalo v tabličnem računalniku, ali izgubo podatkov, ki sta posledica uporabe teh aplikacij, odgovorni izključno sami."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Aplikacije iz neznanih virov lažje napadejo telefon in osebne podatke. Strinjate se, da ste izključno sami odgovorni za morebitno škodo, nastalo v telefonu, ali izgubo podatkov, ki sta posledica uporabe teh aplikacij."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Dodatne nastavitve"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Omogoči več možnosti nastavitev."</string>
    <string name="application_info_label" msgid="5736524913065714880">"Podatki o aplikaciji"</string>
    <string name="storage_label" msgid="8700867073480107253">"Prostor za shranjevanje"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Privzeti zagon"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Privzete nastavitve"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Združljivost zaslona"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Dovoljenja"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Predpomnilnik"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Počisti predpomnilnik"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Predpomnilnik"</string>
    <string name="controls_label" msgid="7611113077086853799">"Kontrolniki"</string>
    <string name="force_stop" msgid="7435006169872876756">"Prisilna ustavitev"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Skupaj"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Aplikacija"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikacija na pogonu USB"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Podatki"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Podatki na pogonu USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Kartica SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Odstrani"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Odstrani za vse uporabnike"</string>
    <string name="install_text" msgid="884360662922471113">"Namesti"</string>
    <string name="disable_text" msgid="6544054052049395202">"Onemogoči"</string>
    <string name="enable_text" msgid="9217362512327828987">"Omogoči"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Počisti podatke"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Odstrani posodobitve"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Izbrali ste, da se bo pri nekaterih dejanjih ta aplikacija samodejno zagnala."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Aplikaciji dovolite, da ustvari pripomočke in dostopa do njihovih podatkov."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Ni privzetih nastavitev."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Počisti privzete nastavitve"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ta aplikacija morda ni namenjena za vaš zaslon. Tu lahko nastavite način prilagajanja zaslonu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Vprašaj, ko se zažene"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Upravljanje aplikacij"</string>
    <string name="unknown" msgid="1592123443519355854">"Neznano"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Razvrsti po imenu"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Razvrsti po velikosti"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Pokaži storitve, ki se izvajajo"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Pokaži predpom. procese"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Ponast. nast. aplikacije"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Ponastavitev nastavitev?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"S tem se bodo ponastavile vse nastavitve za:\n\n "<li>"onemogočene aplikacije,"</li>\n" "<li>"obvestila za onemogočene aplikacije,"</li>\n" "<li>"privzete aplikacije za dejanja,"</li>\n" "<li>"omejitev prenosa podatkov v ozadju za aplikacije,"</li>\n" "<li>"omejitve dovoljenj."</li>\n\n" Podatkov iz aplikacij ne boste izgubili."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Ponastavitev aplikacij"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Upravljaj prostor"</string>
    <string name="filter" msgid="2018011724373033887">"Filtriraj"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Izberite možnosti filtriranja"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Vse"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Onemogočene"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Preneseno"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Se izvaja"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Pomnilnik USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na kartici SD"</string>
    <string name="disabled" msgid="9206776641295849915">"Onemogočeno"</string>
    <string name="not_installed" msgid="2797554494953450291">"Ni namešč. za tega uporabnika"</string>
    <string name="no_applications" msgid="7336588977497084921">"Ni aplikacij."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Notranji pomnilnik"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Pomnilnik USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Shramba na kartici SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Preračunavanje velikosti ..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Želite izbrisati podatke aplikacije?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Vsi podatki te aplikacije bodo trajno izbrisani. To med drugim vključuje vse datoteke, nastavitve, račune in podatkovne zbirke."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"V redu"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Prekliči"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"Aplikacije ni bilo mogoče najti na seznamu nameščenih aplikacij."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Podatkov aplikacije ni bilo mogoče izbrisati."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Želite odstraniti posodobitve?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Vse posodobitve aplikacije sistema Android bodo odstranjene."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Počisti podatke"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Podatkov za aplikacijo ni bilo mogoče izbrisati."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Ta aplikacija ima v tabličnem računalniku dostop do:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Ta aplikacija ima v telefonu dostop do tega:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Aplikacija lahko dostopa do naslednjih elementov v vašem tabličnem računalniku. Da bi izboljšali učinkovitost in zmanjšali porabo pomnilnika, za <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> velja nekaj od teh dovoljenj, saj se izvaja v istem procesu kot <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Aplikacija lahko dostopa do naslednjih elementov v telefonu. Da bi izboljšali učinkovitost in zmanjšali porabo pomnilnika, za <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> velja nekaj od teh dovoljenj, saj se izvaja v istem procesu kot <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> in <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> in <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Ta aplikacija vam lahko zaračuna stroške:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Pošlji SMS za plačljive storitve"</string>
    <string name="computing_size" msgid="1599186977475211186">"Izračunavanje ..."</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Velikosti paketa ni bilo mogoče izračunati."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Nimate nameščenih aplikacij drugih ponudnikov."</string>
    <string name="version_text" msgid="9189073826278676425">"različica <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Premakni"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Premakni v tablični računalnik"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Premakni v telefon"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Premakni na pomnilnik USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Premakni na kartico SD"</string>
    <string name="moving" msgid="6431016143218876491">"Premikanje"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Ni dovolj prostora za shranjevanje."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"Aplikacija ne obstaja."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplikacija je zaščitena pred kopiranjem."</string>
    <string name="invalid_location" msgid="2786030127356312746">"Mesto namestitve ni veljavno."</string>
    <string name="system_package" msgid="6222593098063037137">"Sistemskih posodobitev ni mogoče namestiti na zunanji medij."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Želite prisilno ustaviti?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Če boste vsilili zaustavitev aplikacije, morda ne bo pravilno delovala."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Aplikacije ni bilo mogoče premakniti. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Prednostno namestitveno mesto"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Spremenite prednostno namestitveno mesto za nove aplikacije."</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Želite onemogočiti vgrajeno aplikacijo?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Če onemogočite vgrajeno aplikacijo, bodo druge aplikacije morda nepravilno delovale."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Ali želite izbrisati podatke in onemogočiti aplikacijo?"</string>
    <string name="app_special_disable_dlg_text" msgid="3447657419284854195">"Če onemogočite vgrajeno aplikacijo, lahko druge aplikacije napačno delujejo. Izbrisali boste tudi podatke."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Želite izklopiti obvestila?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Če izklopite obvestila za to aplikacijo, boste morda zamudili pomembna opozorila in posodobitve."</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Delovanje aplikacij"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Se izvaja"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nikoli uporabljeno)"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Uporaba pomnilnika"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Ogled pomnilnika, ki ga uporabljajo aplikacije"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Zagnane storitve"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Preglejte in nadzorujte storitve, ki so trenutno zagnane"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Ponovno zaganjanje"</string>
    <string name="cached" msgid="1059590879740175019">"Predpomnjeni procesi v ozadju"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nič se ne izvaja."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Zagnala aplikacija."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"Prosto: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"V uporabi: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Uporabnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Odstranjen uporabnik"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces, <xliff:g id="NUMSERVICES">%2$d</xliff:g> storitev"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g>proces, število storitev: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesov in <xliff:g id="NUMSERVICES">%2$d</xliff:g> storitev"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"Število procesov: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, število storitev: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Pomnilnik naprave"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Poraba RAM-a za aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Prosto"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Uporabljeno"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"Predpomnjeno"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Aplikacija, ki se izvaja"</string>
    <string name="no_services" msgid="7133900764462288263">"Nedejavno"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Storitve"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesi"</string>
    <string name="service_stop" msgid="6369807553277527248">"Ustavi"</string>
    <string name="service_manage" msgid="1876642087421959194">"Nastavitve"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"To storitev je zagnala aplikacija. Če jo ustavite, aplikacija morda ne bo delovala."</string>
    <string name="heavy_weight_stop_description" msgid="2979218727598321095">"Aplikacije ni mogoče varno ustaviti. Če jo ustavite, boste morda izgubili nekaj svojega trenutnega dela."</string>
    <string name="background_process_stop_description" msgid="5034773197139654588">"To je star proces aplikacije, ki se še vedno izvaja, če bi ga potrebovali. Običajno ga ni treba ustaviti."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutno v uporabi. Za nadzor se dotaknite gumba »Nastavitve«"</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Glavni proces je v uporabi."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Storitev <xliff:g id="COMP_NAME">%1$s</xliff:g> je v uporabi."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Ponudnik <xliff:g id="COMP_NAME">%1$s</xliff:g> je v uporabi."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Želite ustaviti sistemsko storitev?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Če ustavite to storitev, lahko nekatere funkcije v tabličnem računalniku nehajo pravilno delovati, dokler ga ne izklopite in znova vklopite."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Če ustavite to stgoritev, lahko nekatere funkcije v telefonu nehajo pravilno delovati, dokler ga ne izklopite in znova vklopite."</string>
    <string name="language_settings" msgid="5292716747264442359">"Jezik in vnos"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Jezik in vnos"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Nastavitve jezika"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tipkovnica in načini vnosa"</string>
    <string name="phone_language" msgid="8870144109924299673">"Jezik"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Samodejno zamenjaj"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Popravi napačno natipkane besede"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Samodejna uporaba velikih začetnic"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Uporaba velike začetnice za prvo črko v stavku"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Samodejno vstavljanje ločil"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Nastavitve fizične tipkovnice"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Dvakrat pritisnite preslednico, da vnesete ».«"</string>
    <string name="show_password" msgid="3001113966880559611">"Gesla so vidna"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Ta način vnosa lahko morda zbere besedilo, ki ga vtipkate, vključno z osebnimi podatki, kot so gesla in številke kreditnih kartic. Omogoča ga aplikacija <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Ali želite uporabiti ta način vnosa?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ta pregledovalnik črkovanja bo morda lahko zbral vse besedilo, ki ga vnesete, vključno z osebnimi podatki, kot so gesla in številke kreditnih kartic. Pregledovalnik je iz aplikacije <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Ga želite uporabiti?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Nastavitve"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Jezik"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Ni mogoče odpreti nastavitev za <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g>"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Miška/sledilna ploščica"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Hitrost kazalca"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Krmilnik za igre"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Uporaba vibriranja"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Preusmeritev vibriranja v krmilnik za igre, ko je povezan."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Izbira razporeditve tipkovnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Nastavitev razporeditev tipkovnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Preklopite s Ctrl + preslednica"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Privzeto"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Razporeditve tipkovnice"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Osebni slovar"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Dodaj v slovar"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Besedna zveza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Več možnosti"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Manj možnosti"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"V redu"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Beseda:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Bližnjica:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Vnesite besedo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Izbirna bližnjica"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Uredi besedo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Uredi"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"V uporabniškem slovarju ni besed. Besede lahko dodate z dotikom gumba »Dodaj« (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Za vse jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Več jezikov ..."</string>
    <string name="testing" msgid="6584352735303604146">"Preizkušanje"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informacije o tabličnem računalniku"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informacije o telefonu"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Informacije o bateriji"</string>
    <string name="quick_launch_title" msgid="7904609846945905306">"Hitri zagon"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Nastavi bližnjice na tipkovnici za zagon aplikacij"</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Določite aplikacijo"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Ni bližnjice"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Išči + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Počisti"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Bližnjica za aplikacijo <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) bo izbrisana."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"V redu"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Prekliči"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Aplikacije"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Bližnjice"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Vnos besedila"</string>
    <string name="input_method" msgid="5434026103176856164">"Vnosna metoda"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Trenutna tipkovnica"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Izbirnik načina vnosa"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Samodejno"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Vedno pokaži"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Vedno skrij"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Nastavitev načinov vnosa"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Nastavitve"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Nastavitve"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktivni načini vnosa"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Uporaba sistemskega jezika"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Nastavitve za <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Izbira aktivnih načinov vnosa"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Nastavitve zaslonske tipkovnice"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fizična tipkovnica"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Nastavitve fizične tipkovnice"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Možnosti za razvijalce"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Nastavi možnosti za razvoj aplikacij"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Možnosti razvijalca niso na voljo za tega uporabnika"</string>
    <string name="vpn_settings_not_available" msgid="956841430176985598">"Nastavitve VPN niso na voljo za tega uporabnika"</string>
    <string name="tethering_settings_not_available" msgid="6765770438438291012">"Nastavitve za povezavo z internetom prek mobilne naprave niso na voljo za tega uporabnika"</string>
    <string name="apn_settings_not_available" msgid="7873729032165324000">"Nastavitve imena dostopne točke niso na voljo za tega uporabnika"</string>
    <string name="enable_adb" msgid="7982306934419797485">"Odpravljanje težav s povezavo USB"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Način za odpravljanje težav, ko je vzpostavljena povezava USB"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Preklic dovoljenj za odpravljanje težav prek povezave USB"</string>
    <string name="bugreport_in_power" msgid="7923901846375587241">"Bližnjica za poročanje o napakah"</string>
    <string name="bugreport_in_power_summary" msgid="1778455732762984579">"Prikaz gumba za ustvarjanje poročila o napakah v meniju za vklop/izklop"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Brez zaklepanja"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Med polnjenjem se zaslon ne bo nikoli zaklenil"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Omogoči dnevnik vohljanja Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Zajemi vse pakete Bluetooth HCI v datoteko"</string>
    <string name="oem_unlock_enable" msgid="6040763321967327691">"Odklepanje OEM"</string>
    <string name="oem_unlock_enable_summary" msgid="4720281828891618376">"Dovoli odklepanje zagonskega nalagalnika"</string>
    <string name="oem_unlock_enable_pin_prompt" msgid="2398518281753145705">"Vnesite kodo PIN"</string>
    <string name="oem_unlock_enable_pin_description" msgid="1373634087885107329">"Če želite omogočiti odklepanje OEM, vnesite kodo PIN naprave"</string>
    <string name="confirm_enable_oem_unlock_title" msgid="4802157344812385674">"Želite omogočiti odklepanje OEM?"</string>
    <string name="confirm_enable_oem_unlock_text" msgid="5517144575601647022">"OPOZORILO: Ko je vklopljena ta nastavitev, funkcije za zaščito naprave v tej napravi ne bodo delovale."</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Potrdilo brezžičnega zaslona"</string>
    <string name="wifi_verbose_logging" msgid="4203729756047242344">"Omogoči podrob. zapis. dnevnika za Wi-Fi"</string>
    <string name="wifi_aggressive_handover" msgid="9194078645887480917">"Odločen prehod iz Wi-Fi-ja v mobil. omr."</string>
    <string name="wifi_allow_scan_with_traffic" msgid="3601853081178265786">"Vedno omogoči iskanje omrežij Wi-Fi za gostovanje"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Pokaži možnosti za potrdilo brezžičnega zaslona"</string>
    <string name="wifi_verbose_logging_summary" msgid="6615071616111731958">"Povečaj raven zapis. dnev. za Wi-Fi; v izbir. Wi‑Fi-ja pokaži glede na SSID RSSI"</string>
    <string name="wifi_aggressive_handover_summary" msgid="6328455667642570371">"Če je ta možnost omogočena, Wi-Fi odločneje preda podatkovno povezavo mobilnemu omrežju, ko je signal Wi-Fi šibek"</string>
    <string name="wifi_allow_scan_with_traffic_summary" msgid="2575101424972686310">"Omogoči/onemogoči iskanje omrežij Wi-Fi za gostovanje glede na količino podatkovnega prometa pri vmesniku"</string>
    <string name="select_logd_size_title" msgid="7433137108348553508">"Velikosti medpomnilnikov zapisovalnika dnevnika"</string>
    <string name="select_logd_size_dialog_title" msgid="1206769310236476760">"Velik. zap. dnev. za medpom. dnev."</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Dovoli lažne lokacije"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Dovoli lažne lokacije"</string>
    <string name="debug_view_attributes" msgid="6485448367803310384">"Omogoči pregled atributa pogleda"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Ali dovolite odpravljanje težav s povezavo USB?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Odpravljanje težav s povezavo USB je namenjeno samo za razvoj. Lahko ga uporabljate za kopiranje podatkov med računalnikom in napravo, nameščanje aplikacij v napravo brez obveščanja in branje podatkov v dnevniku."</string>
    <string name="adb_keys_warning_message" msgid="6932230298032192937">"Ali želite preklicati dostop do odpravljanja težav prek povezave USB iz vseh računalnikov, ki ste jih pooblastili?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Ali želite omogočiti nastavitve za razvijanje?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Te nastavitve so namenjene samo za razvijanje in lahko povzročijo prekinitev ali napačno delovanje naprave in aplikacij v njej."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Preveri apl., namešč. z USB-jem"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Preveri, ali so aplikacije, nameščene prek ADB/ADT, škodljive."</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Zaščiti shrambo USB"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Aplikacije morajo zahtevati dovoljenje za branje shrambe USB"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Želite zaščititi shrambo USB?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Če je shramba USB zaščitena, morajo aplikacije zahtevati dovoljenje za branje podatkov iz zunanje shrambe.\n\nNekatere aplikacije morda ne bodo delovale, dokler jih njihovi razvijalci ne posodobijo."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Zaščiti kartico SD"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Aplikacije morajo zahtevati dovoljenje za branje kartice SD"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Želite zaščititi kartico SD?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Če je kartica SD zaščitena, morajo aplikacije zahtevati dovoljenje za branje podatkov iz zunanje shrambe.\n\nNekatere aplikacije morda ne bodo delovale, dokler jih njihovi razvijalci ne posodobijo."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Lokalni terminal"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Omogočanje terminalske aplikacije za dostop do lokalne lupine"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Izberi pripomoček"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Izberite pripomoček"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Želite ustvariti pripomoček in dovoliti dostop?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Ko ustvarite pripomoček, ima <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> dostop do vseh podatkov, ki jih ta prikazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Vedno dovoli, da <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> ustvari pripomočke in dostopa do njihovih podatkov"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g>d <xliff:g id="HOURS">%2$d</xliff:g>h <xliff:g id="MINUTES">%3$d</xliff:g>m <xliff:g id="SECONDS">%4$d</xliff:g>s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g>h <xliff:g id="MINUTES">%2$d</xliff:g>m <xliff:g id="SECONDS">%3$d</xliff:g>s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g>m <xliff:g id="SECONDS">%2$d</xliff:g>s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min"</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistika uporabe"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistika uporabe"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Razvrsti po:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacija"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Zadnjič uporabljeno"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Čas uporabe"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Pripomočki za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Nastavitve pripomočkov za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Storitve"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Sistem"</string>
    <string name="accessibility_display_title" msgid="7610175687949675162">"Zaslon"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Napisi"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Poteze za povečavo"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2380627654189671754">"Če je ta funkcija vklopljena, lahko vsebino na zaslonu povečate ali pomanjšate tako, da se trikrat dotaknete zaslona.\n\nPri povečavi lahko:\n"<ul><li>"Pomikate vsebino na zaslonu: Dva prsta ali več povlecite po zaslonu."</li>\n<li>"Prilagodite stopnjo povečave/pomanjšave: Najmanj dva prsta približajte ali razširite."</li></ul>\n\n"Začasno lahko tisto, kar je pod vašim prstom, povečate tudi tako, da se zaslona trikrat dotaknete in ga pridržite. V tem načinu povečave lahko povlečete s prstom in raziščete različne dele zaslona. Dvignite prst, če se želite vrniti v prejšnje stanje.\n\nOpomba: Trojni dotik za povečavo deluje povsod, razen pri tipkovnici in v vrstici za krmarjenje"</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Bližnj. prip. za ljudi s pos. pot."</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Vklopljeno"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Izklopljeno"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"Če je ta funkcija vklopljena, lahko v dveh korakih hitro omogočite funkcije za ljudi s posebnimi potrebami:\n\n1. korak: Pritisnite in pridržite gumb za vklop, dokler ne zaslišite zvoka ali začutite vibracije.\n\n2. korak: Dotaknite se zaslona z dvema prstoma in pridržite, dokler ne zaslišite zvočne potrditve.\n\nČe napravo uporablja več uporabnikov, z uporabo te bližnjice na zaslonu za zaklepanje začasno omogočite funkcije za ljudi s posebnimi potrebami, dokler naprave ne odklenete."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Veliko besedilo"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Visokokontrastno besedilo"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Povečava zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Samodejno posodobi povečavo zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Posodabljanje povečave zaslona pri prehodih aplik."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Gumb za vklop konča klic"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Izgovarjanje gesel"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Časovni zam. za dotik in pridržanje"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inverzija barv"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="8658240868230680912">"(Preskusno) Lahko vpliva na učinkovitost delovanja"</string>
    <string name="accessibility_display_daltonizer_preference_title" msgid="5800761362678707872">"Popravljanje barv"</string>
    <string name="accessibility_display_daltonizer_preference_subtitle" msgid="3484969015295282911">"To je preskusna funkcija in lahko vpliva na učinkovitost delovanja."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Prikaži v »Hitrih nastavitvah«"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Način za popravljanje"</string>
    <string name="daltonizer_type_overridden" msgid="3116947244410245916">"Preglasila nastavitev: <xliff:g id="TITLE">%1$s</xliff:g>"</string>
    <string name="daltonizer_mode_disabled" msgid="7482661936053801862">"Onemogočeno"</string>
    <string name="daltonizer_mode_monochromacy" msgid="8485709880666106721">"Monokromatičnost"</string>
    <string name="daltonizer_mode_deuteranomaly" msgid="5475532989673586329">"Devteranomalija (rdeča – zelena)"</string>
    <string name="daltonizer_mode_protanomaly" msgid="8424148009038666065">"Protanomalija (rdeča – zelena)"</string>
    <string name="daltonizer_mode_tritanomaly" msgid="481725854987912389">"Tritanomalija (modra – rumena)"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Nastavitve"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Vklopljeno"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Izkloplj."</string>
    <string name="accessibility_feature_or_input_method_not_allowed" msgid="5950315477009501647">"Organizacija tega ne dovoljuje"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Predogled"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standardne možnosti"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Jezik"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Velikost besedila"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Slog napisov"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Možnosti po meri"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Barva ozadja"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Neprosojnost ozadja"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Barva oken za napise"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Neprosojnost oken za napise"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Barva besedila"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Neprosojnost besedila"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Barva roba"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Vrsta roba"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Skupina pisav"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Napisi bodo videti tako:"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Privzeto"</string>
    <string name="color_title" msgid="4258931051732243983">"Barva"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Privzeto"</string>
    <string name="color_none" msgid="3475640044925814795">"Brez"</string>
    <string name="color_white" msgid="8045195170201590239">"Bela"</string>
    <string name="color_gray" msgid="9192312087142726313">"Siva"</string>
    <string name="color_black" msgid="7517353520909872561">"Črna"</string>
    <string name="color_red" msgid="4949354900304125428">"Rdeča"</string>
    <string name="color_green" msgid="5537717328428845841">"Zelena"</string>
    <string name="color_blue" msgid="7731984529016953223">"Modra"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cijan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Rumena"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Magenta"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Želite uporabiti storitev <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> mora:"</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Če vklopite storitev <xliff:g id="SERVICE">%1$s</xliff:g>, vaša naprava ne bo uporabljala zaklepanja zaslona za izboljšanje šifriranja podatkov."</string>
    <string name="secure_lock_encryption_warning" msgid="464101518421886337">"Vaša naprava ne bo uporabljala zaklepanja zaslona za izboljšanje šifriranja podatkov, ker ste vklopili storitev za ljudi s posebnimi potrebami."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Ker vklop storitve <xliff:g id="SERVICE">%1$s</xliff:g> vpliva na šifriranje podatkov, morate potrditi vzorec."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Ker vklop storitve <xliff:g id="SERVICE">%1$s</xliff:g> vpliva na šifriranje podatkov, morate potrditi kodo PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Ker vklop storitve <xliff:g id="SERVICE">%1$s</xliff:g> vpliva na šifriranje podatkov, morate potrditi geslo."</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Opazujte svoja dejanja"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="2095111008854376237">"Prejmite obvestila, ko uporabljate aplikacijo."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Ali želite ustaviti storitev <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2012273739481042318">"Če se dotaknete »V redu«, ustavite storitev <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nameščena ni nobena storitev"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Ni opisa."</string>
    <string name="settings_button" msgid="3006713718908152930">"Nastavitve"</string>
    <string name="print_settings" msgid="4742428530112487843">"Tiskanje"</string>
    <string name="print_settings_title" msgid="3685449667822217816">"Tiskalne storitve"</string>
    <string name="print_service_security_warning_title" msgid="2338435517408144841">"Želite uporabiti storitev <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="print_service_security_warning_summary" msgid="7567131958613064363">"Dokument gre lahko na poti do tiskalnika skozi enega ali več strežnikov."</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nameščena ni nobena storitev"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Tiskalnikov ni mogoče najti"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Nastavitve"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Dodajanje tiskalnikov"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Vklop"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Izklop"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Dodaj storitev"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Dodajanje tiskalnika"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Iskanje"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Iskanje tiskalnikov"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Storitev je onemogočena"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Zahteve za tiskanje"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Tiskalno opravilo"</string>
    <string name="print_restart" msgid="8373999687329384202">"Začni znova"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Prekliči"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Tiskanje: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Preklic: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Napaka tiskalnika: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Tiskalnik je blokiral <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Iskalno polje je prikazano"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Iskalno polje je skrito"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Akumulator"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Kaj porablja energijo baterije"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Podatki o porabi baterije niso na voljo."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Preostali čas: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do napolnjenosti"</string>
    <string name="power_discharging_duration" msgid="1605929174734600590">"<xliff:g id="LEVEL">%1$s</xliff:g> – še približno <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="power_charging" msgid="1779532561355864267">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATE">%2$s</xliff:g>"</string>
    <string name="power_charging_duration" msgid="2853265177761520490">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do napolnjenosti"</string>
    <string name="power_charging_duration_ac" msgid="3969186192576594254">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do napolnjenosti prek napajalnika"</string>
    <string name="power_charging_duration_usb" msgid="182405645340976546">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do napolnjenosti prek USB-ja"</string>
    <string name="power_charging_duration_wireless" msgid="1829295708243159464">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do napolnjenosti prek brezž. pol."</string>
    <string name="power_usage_list_summary" msgid="2409288197839512482">"Uporaba od zadnje polne napolnjenosti"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Uporaba baterije po odklopu"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Uporaba baterije od ponastavitve"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"Čas napajanja iz baterije: <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od odklopa"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Napajanje"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Zaslon vklopljen"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS:"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi‑Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Z odklenjenim zaslonom"</string>
    <string name="battery_stats_phone_signal_label" msgid="3537569115723850618">"Signal mobilnega omrežja"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Čas odklenjenega zaslona"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Čas z vklopljenim Wi-Fi-jem"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Čas z vklopljenim Wi-Fi-jem"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Podrobnosti zgodovine"</string>
    <string name="details_title" msgid="3792801565213935385">"Podrobnosti uporabe"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Podrobnosti uporabe"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Prilagodi porabo energije"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Vključeni paketi"</string>
    <string name="power_screen" msgid="3023346080675904613">"Zaslon"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Svetilka"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Stanje pripravljenosti"</string>
    <string name="power_phone" msgid="5392641106474567277">"Glasovni klici"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablični računalnik nedejaven"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon je nedejaven"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Razno"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Preveč šteto"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Skupni čas za CPE"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"Ospredje CPE"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Ohrani odklenjen zaslon"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi vklopljen"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablični računalnik"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Paketi, poslani v mob. omrežju"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Paketi, prejeti v mob. omrežju"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Mobilna radijska enota aktivna"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Paketi, poslani v omrežju Wi-Fi"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Paketi, prejeti v omrežju Wi-Fi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Zvok"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Trajanje osvetlitve"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Čas brez signala"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Skupna zmogljivost akumulatorja"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Izračunana poraba energije"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Zaznana poraba energije"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Prisilna ustavitev"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Podatki o aplikaciji"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Nastavitve aplikacij"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Nastavitve zaslona"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Nastavitve za Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Nastavitve Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Energija, ki so jo porabili glasovni klici"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Uporaba baterije, ko je tablični računalnik nedejaven"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Poraba energije, kadar je telefon nedejaven"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Energija, ki jo je porabil radijski vmesnik"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Na območjih brez mobilnega signala preklopite v način za letalo, da prihranite energijo"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Energija, porabljena za bliskavico"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Energija, porabljena za osvetlitev zaslona"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Zmanjšajte svetlost zaslona in/ali časovno omejitev za vklop zaslona"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Energija, ki jo je porabil Wi‑Fi"</string>
    <string name="battery_sugg_wifi" msgid="3355461362094706957">"Izklopite Wi-Fi, ko ga ne uporabljate ali če ni na voljo"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Energija, ki jo je porabil Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Izklopite funkcijo Bluetooth, kadar je ne uporabljate"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Poskusite vzpostaviti povezavo z drugo napravo Bluetooth"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Energija, ki jo je porabila aplikacija"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Ustavi ali odstrani aplikacijo"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Izberite način za varčevanje z energijo akumulatorja"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacija morda omogoča nastavitve za zmanjšanje porabe energije"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Energija, ki jo je porabil uporabnik"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Drugi viri porabe energije"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Poraba akumulatorja je približek porabe energije in ne vključuje vseh virov porabe akumulatorja. »Drugi viri« so razlika med izračunano približno porabo energije in dejansko porabo, zaznano pri akumulatorju."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Preveč šteta uporaba energije"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od odklopa"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Po zadnjem odklopu za <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Skupna poraba"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Osveži"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"OS Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Predstavnostni strežnik"</string>
    <string name="battery_saver" msgid="1426682272004907982">"Varčevanje z energijo akumulatorja"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Samodejni vklop"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikoli"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="7536784431655058267">"pri %1$s akumulatorja"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistični podatki o procesih"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Statistični podatki o procesih, ki se izvajajo"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Poraba pomnilnika"</string>
    <string name="process_stats_total_duration" msgid="1869761515101180444">"Vrsta aplikacij: <xliff:g id="TYPE">%1$s</xliff:g> – časovno obdobje: <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"V ozadju"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"V ospredju"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Predpomnjeni"</string>
    <string name="process_stats_memory_status" msgid="4251599550196193093">"Trenutno stanje pomnilnika naprave: <xliff:g id="MEMSTATE">%1$s</xliff:g>"</string>
    <string name="process_stats_avg_ram_use" msgid="6972943528929394396">"Povprečna uporaba RAM-a"</string>
    <string name="process_stats_max_ram_use" msgid="3273876448926689261">"Največja uporaba RAM-a"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Trajanje izvajanja"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Storitve"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Trajanje"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Podrobnosti pomnilnika"</string>
    <string name="mem_state_subtitle" msgid="2407238869781011933">"Stanja pomnilnika"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Uporaba pomnilnika"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Jedro"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Izvorno"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Predpomnjeno v jedru"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"Zamenjava pomnilnika ZRam"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"Prosto"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Skupaj"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 ure"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 ur"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 ur"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 dan"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Prikaz sistemskih"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Uporaba USS-ja"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Vrsta statističnih podatkov"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"V ozadju"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"V ospredju"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Predpomnjeni"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Glasovni vnos in izhod"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Nastavitve glasovnega vnosa in izhoda"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Glasovno iskanje"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Tipkovnica Android"</string>
    <string name="voice_category" msgid="1430370497125803904">"Govor"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Nastavitve glasovnega vnosa"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Glasovni vnos"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Storitve glasovnega vnosa"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Polna uporaba sprožilnih besed in govora"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Pretvorba preprostega govora v besedilo"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Storitev glasovnega vnosa bo lahko izvajala stalno vklopljeno nadziranje glasu in v vašem imenu upravljala aplikacije, ki omogočajo glasovno upravljanje. Storitev izvira iz aplikacije <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Želite omogočiti njeno uporabo?"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Nastavitve pretvorbe besedila v govor"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Pretvorba besedila v govor"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Vedno uporabi moje nastavitve"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Spodnje privzete nastavitve preglasijo nastavitve aplikacij"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Privzete nastavitve"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Privzeti mehanizem"</string>
    <string name="tts_default_synth_summary" msgid="6482936537135251690">"Nastavi mehanizem za sintezo govora, ki se bo uporabljal za branje besedila"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Hitrost govora"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Hitrost govorjenega besedila"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Višina tona"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Vpliva na ton govorjenega besedila"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Jezik"</string>
    <string name="tts_lang_use_system" msgid="2679252467416513208">"Uporaba sistemskega jezika"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Jezik ni izbran"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Nastavite glas, odvisen od jezika, za govorjeno besedilo"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Poslušaj primer"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Predvajaj kratko predstavitev sinteze govora"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Namesti glasovne podatke"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Namestite govorne datoteke, ki jih potrebujete za sintezo govora"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Glasovi, ki jih potrebujete za sintezo govora, so že pravilno nameščeni"</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Nastavitve so spremenjene. To je primer, kako so slišati."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Izbranega mehanizma ni mogoče zagnati."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Konfiguriraj"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Izberite drug mehanizem"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Ta mehanizem za sintezo govora bo morda lahko zbiral izgovorjeno besedilo, vključno z osebnimi podatki, kot so gesla in številke kreditnih kartic. Omogoča ga mehanizem <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Ali želite omogočiti uporabo tega mehanizma za sintezo govora?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"Za pretvorbo besedila v govor potrebuje ta jezik delujočo omrežno povezavo."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"To je primer sinteze govora."</string>
    <string name="tts_status_title" msgid="7268566550242584413">"Stanje privzetega jezika"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"Jezik <xliff:g id="LOCALE">%1$s</xliff:g> je v celoti podprt"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"<xliff:g id="LOCALE">%1$s</xliff:g> zahteva omrežno povezavo"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"Jezik <xliff:g id="LOCALE">%1$s</xliff:g> ni podprt"</string>
    <string name="tts_status_checking" msgid="4983413982985913047">"Preverjanje ..."</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Mehanizmi"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"Nastavitve za <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"Mehanizem <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je omogočen"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"Mehanizem <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je onemogočen"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Nastavitve mehanizma"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Nastavitve za <xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Jeziki in glasovi"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Nameščeno"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Ni nameščeno"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Ženski"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Moški"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Mehanizem za sintezo govora nameščen"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Pred upor. omogoč. nov mehan."</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Zagon nastavitev mehanizma"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Prednostni mehanizem"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Splošno"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Nadzor porabe"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Posodabljanje nastavitve Wi‑Fi-ja"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Posodabljanje nastavitev Bluetooth"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"vklopljeno"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"izklopljeno"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"vklapljanje"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"izklapljanje"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi‑Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Lokacija"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sinhronizacija"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Svetlost <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"samodejno"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"najsvetleje"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"polovično"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"izklopljeno"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Shramba poverilnic"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Namesti iz shrambe"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Namesti s kartice SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Namesti potrdila iz shrambe"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Namesti potrdila s kartice SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Brisanje poverilnic"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Odstrani vsa potrdila"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Preverjene poverilnice"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Prikaži zaupanja vredna potrdila overiteljev"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Dodatno"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Vrsta shrambe"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Strojna"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Samo programska"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Za tega uporabnika niso na voljo poverilnice"</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Če želite potrditi ponastavitev na tovarniške nastavitve, morate narisati vzorec za odklepanje."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Vnesite geslo za shrambo poverilnic."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Trenutno geslo:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Želite odstraniti vso vsebino?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Geslo mora imeti vsaj 8 znakov"</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Napačno geslo."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Napačno geslo. Poskusite lahko še enkrat, preden se shramba poverilnic izbriše."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Napačno geslo. Poskusite lahko še <xliff:g id="NUMBER">%1$d</xliff:g>-krat, preden se shramba poverilnic izbriše."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Shramba poverilnic je izbrisana."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Shrambe pover. ni mogoče izbr."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Shramba poverilnic je omogočena."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Preden lahko uporabite shrambo poverilnic, morate nastaviti kodo PIN ali geslo za zaklepanje zaslona."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Apl. z dost. do pod. o uporabi"</string>
    <string name="allow_usage_access_title" msgid="2134237975190472249">"Želite omogočiti dostop?"</string>
    <string name="allow_usage_access_message" msgid="2295847177051307496">"Če tej aplikaciji omogočite dostop, ji bodo dostopni splošni podatki o aplikacijah v napravi, na primer, kako pogosto jih uporabljate."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Ton v sili"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Nastavi način delovanja ob klicanju v sili"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Izdelaj varnostno kopijo in ponastavi"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Izdelaj varnostno kopijo in ponastavi"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Varnostno kopiranje in obnovitev"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Osebni podatki"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Varnostno kopiraj moje podatke"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Varnostno kopiranje podatkov aplikacij, gesel za Wi-Fi in drugih nastavitev v Googlove strežnike"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Varnostno kopiranje računa"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Trenutno v nobenem računu niso shranjeni varnostno kopirani podatki"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Vključi podatke aplikacije"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Samodejna obnovitev"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Pri vnovični namestitvi aplikacije obnovite varnostno kopirane nastavitve in podatke"</string>
    <string name="backup_inactive_title" msgid="5355557151569037197">"Storitev za varnostno kopiranje je nedejavna."</string>
    <string name="backup_inactive_summary" msgid="7630412094703573180">"To je nastavljeno s pravilnikom za naprave."</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Geslo za varn. kop. rač."</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"Popolne varnostne kopije namizja trenutno niso zaščitene"</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Dotaknite se, če želite spremeniti ali odstraniti geslo za popolno varnostno kopiranje namizja."</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Novo varnostno geslo je nastavljeno"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Novo geslo in potrditev se ne ujemata."</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Neuspela nastavitev varnostnega gesla"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Ali želite ustaviti varnostno kopiranje gesel za Wi-Fi, zaznamkov, drugih nastavitev in podatkov aplikacij ter izbrisati vse kopije iz Googlovih strežnikov?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Nastavitve skrbništva naprave"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Skrbnik naprave"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Izklopi"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Skrbniki naprave"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Na voljo ni nobenega skrbnika naprave"</string>
    <string name="managed_profile_device_admin_info" msgid="5048846624960067582">"Če želite aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> onemogočiti dostop do delovnega profila, v Nastavitve &gt; Računi odstranite profil"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Osebno"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Delo"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Na voljo ni nobenega posrednika zaupanja"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Ali želite omogočiti skrbnika naprave?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Vklopi"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Skrbnik naprave"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Če omogočite tega skrbnika, bo aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> lahko izvedla te operacije:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Ta skrbnik je aktiven in dovoli aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g>, da izvaja naslednje operacije:"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Želite aktivirati Upravitelja profilov?"</string>
    <string name="adding_profile_owner_warning" msgid="6469780138110334180">"Če nadaljujete, bo uporabnika upravljal skrbnik, ki lahko poleg osebnih podatkov shranjuje tudi povezane podatke.\n\nSkrbnik lahko nadzira in upravlja nastavitve, dostop, aplikacije in podatke, povezane s tem uporabnikom, vključno z omrežno dejavnostjo in podatki o lokaciji naprave."</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Brez naslova"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Splošno"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Dnevnik obvestil"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Ton zvonjenja in vibriranje"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Sistem"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Namestitev povezave Wi‑Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Vzpostavitev povezave z omrežjem Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Vzpostavljanje povezave z omrežjem Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g> …"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Vzpostavljena povezava z omrežjem Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Dodajanje omrežja"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Povezava ni vzpostavljena"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Dodaj omrežje"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Osveži seznam"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Preskoči"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Naprej"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Nazaj"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"O omrežju"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Vzpostavi povezavo"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Pozabi"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Shrani"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Prekliči"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Iskanje omrežij ..."</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Dotaknite se omrežja, da vzpostavite povezavo"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Poveži se z obstoječim omrežjem"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Poveži z nezaščitenim omrežjem"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Vnesite konfiguracijo omrežja"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Poveži se z novim omrežjem"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Povezovanje ..."</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Naprej"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"EAP ni podprt."</string>
    <string name="wifi_setup_eap_not_supported" msgid="1955087534276570962">"Povezave EAP Wi-Fi ne morete nastaviti med namestitvijo. To lahko po namestitvi naredite v Nastavitve &gt; Brezžično in omrežja."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Vzpostavljanje povezave lahko traja nekaj minut ..."</string>
    <string name="wifi_setup_description_connected" msgid="736032046548460779">"Če želite nadaljevati namestitev, se dotaknite "<b>"Naprej"</b>".\n\nČe se želite povezati z drugim omrežjem Wi-Fi, se dotaknite "<b>"Nazaj"</b>"."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinhronizacija omogočena"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sinhronizacija onemogočena"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Sinhronizacija poteka"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Napaka pri sinhronizaciji"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinhronizacija ni uspela"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinhronizacija je aktivna"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinhroniziranje"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Težava pri sinhronizaciji. Kmalu bo spet na voljo."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Dodaj račun"</string>
    <string name="managed_profile_not_available_label" msgid="3489771164851107822">"Delovni profil še ni na voljo"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Odstrani delovni profil"</string>
    <string name="background_data" msgid="5779592891375473817">"Podatki v ozadju"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacije lahko kadar koli sinhronizirajo, pošiljajo in prejemajo podatke"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Želite onemogočiti podatke v ozadju?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Če onemogočite podatke v ozadju, podaljšate življenjsko dobo baterije in zmanjšate rabo podatkov. Nekatere aplikacije bodo mogoče še vedno potrebovale povezavo s podatki v ozadju."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Samodejna sinh. podatkov aplik."</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sinhroniz. je VKLOP."</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sinhron. je IZKLOP."</string>
    <string name="sync_error" msgid="5060969083117872149">"Sinhron. napaka"</string>
    <string name="last_synced" msgid="4242919465367022234">"Zadnje sinhroniziranje: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sinhroniziranje ..."</string>
    <string name="settings_backup" msgid="2274732978260797031">"Varnostno kopiranje nastavitev"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Varnostno kopiranje nastavitev"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinhroniziraj"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Prekliči sinhronizacijo"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Pritisnite, če želite sinhronizirati<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Koledar"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Stiki"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Pozdravljeni v storitvi Google Sync."</font>" \nGooglov pristop k sinhroniziranju podatkov, s katerim lahko dostopate do stikov, koledarskih vnosov in drugih podatkov ne glede na to, kje ste."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Nastavitve sinhronizacije aplikacij"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Podatki in sinhronizacija"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Spremeni geslo"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Nastavitve računa"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Odstrani račun"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Dodajanje računa"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Končaj"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Želite odstraniti račun?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Z odstranitvijo računa boste iz tabličnega računalnika izbrisali vsa sporočila, stike in druge podatke v računu."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Z odstranitvijo računa boste iz telefona izbrisali vsa sporočila, stike in druge podatke v računu."</string>
    <string name="remove_account_failed" msgid="4010643669489606536">"Skrbnik domene ne dovoli te spremembe"</string>
    <string name="provider_label" msgid="7724593781904508866">"Potisne naročnine"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Ročna sinhronizacija ni mogoča"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Sinhronizacija za ta element je trenutno onemogočena. Če želite spremeniti nastavitev, vklopite podatke v ozadju in samodejno sinhronizacijo."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Naslov 4G MAC"</string>
    <string name="enter_password" msgid="8035706727471334122">"Če želite zagnati Android, vnesite geslo"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Če želite zagnati Android, vnesite PIN"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Če želite zagnati Android, narišite vzorec"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Napačen vzorec"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Napačno geslo"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Napačna koda PIN"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Preverjanje ..."</string>
    <string name="starting_android" msgid="8581493237458496835">"Zagon Androida"</string>
    <string name="delete" msgid="4219243412325163003">"Izbriši"</string>
    <string name="misc_files" msgid="6720680815969643497">"Razne datoteke"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"izbrano: <xliff:g id="NUMBER">%1$d</xliff:g> od <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> od skupaj <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Izberi vse"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"Preverjanje HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Nastavi preverjanje HDCP"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Iskanje napak"</string>
    <string name="debug_app" msgid="8349591734751384446">"Izberite aplikacijo za iskanje napak"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Aplikacija za iskanje napak ni nastavljena"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Aplikacija za iskanje napak: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Izberite aplikacijo"</string>
    <string name="no_application" msgid="2813387563129153880">"Nič"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Počakajte na iskalnik napak"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Progr, kjer se išče nap., čaka isk. nap. pred izv."</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Vnos"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Risba"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Upodabljanje s strojnim pospeševanjem"</string>
    <string name="media_category" msgid="4388305075496848353">"Predstavnosti"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Spremljanje"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Strog način je omogočen"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Osveži zaslon pri dolgih oper. progr. v gl. niti"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Mesto kazalca"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Prekriv. zaslona prikazuje tren. podatke za dotik"</string>
    <string name="show_touches" msgid="1356420386500834339">"Pokaži dotike"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Pokaži vizualne povratne informacije za dotike"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Pokaži posodob. površine"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Ob posodobitvi osvetli celotne površine oken"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Pokaži posod. pogleda GPE"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Osvetli poglede v oknih pri risanju z GPE"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Pokaži pos. sl. str. opr."</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Obarvaj sloje strojne opreme zeleno ob posodobitvi"</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Odpr. nap. ris. zunaj vidn. obm. za GPE"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Onem. strojni medp."</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Za sestavljanje slike vedno uporabi graf. procesor"</string>
    <string name="simulate_color_space" msgid="6745847141353345872">"Simul. barvnega prostora"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Omogoči sledi OpenGL"</string>
    <string name="use_awesomeplayer" msgid="1583337008516364226">"Uporabi AwesomePlayer (zastarelo)"</string>
    <string name="use_awesomeplayer_summary" msgid="6757734070733387140">"Uporaba AwesomePlayerja namesto NuPlayerja za predvajanje večine predstavnosti"</string>
    <string name="usb_audio_disable_routing" msgid="8114498436003102671">"On. us. zvoka prek USB-ja"</string>
    <string name="usb_audio_disable_routing_summary" msgid="980282760277312264">"Onem. samod. usmerjanja na zun. zvoč. naprave USB"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Prikaz mej postavitve"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Pokaži meje obrezovanja, obrobe ipd."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Vsili od desne proti levi"</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Vsili smer postavitve na zaslonu od desne proti levi za vse jezike"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Prikaži uporabo CPE-ja"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Prekrivanje zaslona prikazuje tren. uporabo CPE-ja"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Vsili upodabljanje z GPU-jem"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Za risanje 2D vsili uporabo grafičnega procesorja"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Vsili 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"V aplikacijah OpenGL ES 2.0 omogoči 4x MSAA"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Odpr. težav s postopki nepravokotnega izrezovanja"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Upod. profilov z GPU-jem"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Merilo animacije okna"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Merilo animacije prehoda"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Lestvica trajanja animacije"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Simul. sekund. prikazov."</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Aplikacije"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Ne obdrži dejavnosti"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Uniči vsako dejavnost, ko uporabnik preneha z njo"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Omejitev postopkov v ozadju"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Pokaži okna neodzivanj"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Prikaz pogovornega okna za neodzivanje aplikacije v ozadju"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Podatkovni promet"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Poraba podatk. aplikacije"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Operaterjeve meritve porabe podatkov so morda drugačne kot v napravi."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Uporaba aplikacije"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"PODATKI O APLIKACIJI"</string>
    <string name="data_usage_cellular_data" msgid="4859424346276043677">"Prenos podatkov v mobilnih omrežjih"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Nastavitev omejitve prenosa podatkov"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cikel porabe podatkov"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Uporaba aplikacije"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Podatkovno gostovanje"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Omejitev podatkov v ozadju"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Dovoli podatke v ozadju"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Ločena uporaba 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Pokaži porabo za Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Skrij Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Pokaži uporabo etherneta"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Skrij porabo etherneta"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Omejitve omrežja"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Samodejno sinhroniziranje podatkov"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"Kartice SIM"</string>
    <string name="data_usage_menu_cellular_networks" msgid="5243515735055652279">"Mobilna omrežja"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Samod. sinhronizacija podatkov"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Samod. sinhron. oseb. podatkov"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Samod. sinhr. delov. podatkov"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Spremeni cikel ..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Dan za ponastavitev cikla porabe podatkov:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"V tem obdobju ni podatkov uporabljala nobena aplikacija."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Ospredje"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Ozadje"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"omejeno"</string>
    <string name="data_usage_disable_mobile" msgid="2613595056882494652">"Ali želite izklopiti prenos podatkov v mobilnih omrežjih?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="3934211003105066167">"Nast. omej. mob. podatkov"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Nastavi omejitev podatkov za 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Nast. omejitev za EDGE in UMTS"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Nast. omej. pod. za Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="2084466270343460491">"Mobil. om."</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="7219011330831181312">"Mobil. om."</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Brez"</string>
    <string name="data_usage_enable_mobile" msgid="5900650720568852325">"Prenos podatkov v mob. omrežjih"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Podatki 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Podatki 4G"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Ospredje:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Ozadje:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Nastavitve aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="7510046552380574925">"Omeji prenos pod. aplik. v ozad."</string>
    <string name="data_usage_app_restrict_background_summary" msgid="3720075732277934106">"Onemogoči prenos podatkov v ozadju v mobilnih omrežjih."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="1446565717342917727">"Če želite omejiti prenos podatkov v ozadju za to aplikacijo, najprej nastavite omejitev prenosa podatkov v mobilnih omrežjih."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Želite omejiti podatke v ozadju?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5871168521456832764">"Ta funkcija lahko povzroči, da aplikacija, ki je odvisna od prenosa podatkov v ozadju, preneha delovati, če so na voljo samo mobilna omrežja.\n\nUstreznejše možnosti nadzora porabe podatkov lahko najdete v nastavitvah v aplikaciji."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="4674085030810350875">"Prenos podatkov v ozadju lahko omejite samo, če nastavite omejitev prenosa podatkov v mobilnih omrežjih."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Želite vklopiti samodejno sinhroniziranje podatkov?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Morebitne spremembe v računih, ki jih naredite v spletu, bodo samodejno kopirane v tablični računalnik.\n\nNekateri računi morda tudi samodejno kopirajo morebitne spremembe, ki jih naredite v tabličnem računalniku, v splet. Tako deluje Google Račun."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Morebitne spremembe v računih, ki jih naredite v spletu, bodo samodejno kopirane v telefon.\n\nNekateri računi morda tudi samodejno kopirajo morebitne spremembe, ki jih naredite v telefonu, v splet. Tako deluje Google Račun."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Želite izklopiti samodejno sinhroniziranje podatkov?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"S tem zmanjšate količino prenesenih podatkov in porabo akumulatorja, vendar boste morali vsak posamezen račun sinhronizirati ročno, da dobite najnovejše podatke. Prav tako ne boste dobili obvestil o posodobitvah."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Datum ponastavitve cikla porabe"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Datum vsakega meseca:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Nastavi"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Nastavi opozorilo o uporabi podatkov"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Nastavitev omejitve količine prenesenih podatkov"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Omejitev porabe podatkov"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="5788774061143636263">"Tablični računalnik bo izklopil prenos podatkov v mobilnih omrežjih, ko bo dosegel omejitev, ki ste jo nastavili.\n\nKer porabo podatkov meri tablični računalnik, operater pa jo morda drugače, priporočamo, da nastavite nekoliko manjšo omejitev"</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3511301596446820549">"Telefon bo izklopil prenos podatkov v mobilnih omrežjih, ko bo dosegel omejitev, ki ste jo nastavili.\n\nKer porabo podatkov meri telefon, operater pa jo morda drugače, priporočamo, da nastavite nekoliko manjšo omejitev."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Želite omejiti podatke v ozadju?"</string>
    <string name="data_usage_restrict_background" msgid="8210134218644196511">"Če omejite prenos podatkov v mobilnih omrežjih v ozadju, nekatere aplikacije in storitve ne bodo delovale, kadar niste povezani v omrežje Wi-Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="3262993384666280985">"Če omejite prenos podatkov v mobilnih omrežjih v ozadju, nekatere aplikacije in storitve ne bodo delovale, kadar niste povezani v omrežje Wi-Fi.\n\nTa nastavitev velja za vse uporabnike tega tabličnega računalnika."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="4352615206362479722">"Če omejite prenos podatkov v mobilnih omrežjih v ozadju, nekatere aplikacije in storitve ne bodo delovale, kadar niste povezani v omrežje Wi-Fi.\n\nTa nastavitev velja za vse uporabnike tega telefona."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">" <xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"opozorilo"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"omejitev"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Odstranjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Odstranjene aplikacije in uporabniki"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"prejeto: <xliff:g id="RECEIVED">%1$s</xliff:g>, poslano: <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: približna količina prenesenih podatkov: <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="5961720793603268572">"<xliff:g id="RANGE">%2$s</xliff:g>: približna količina prenesenih podatkov, merjena s tabličnim računalnikom: <xliff:g id="TOTAL">%1$s</xliff:g>. Operater jo lahko obračunava drugače."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="1625833170144610767">"<xliff:g id="RANGE">%2$s</xliff:g>: približna količina prenesenih podatkov, merjena s telefonom: <xliff:g id="TOTAL">%1$s</xliff:g>. Operater jo lahko obračunava drugače."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Omejitve omrežja"</string>
    <string name="data_usage_metered_body" msgid="3262343834446126044">"Ko so podatki v ozadju omejeni, se omrežja z omejeno količino prenosa obravnavajo kot mobilna omrežja. V primeru velikih prenosov lahko aplikacije opozorijo pred uporabo teh omrežij."</string>
    <string name="data_usage_metered_mobile" msgid="2326986339431119372">"Mobilna omrežja"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Wi‑Fi z omejeno količ. prenosa"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Če želite izbrati omrežje z omej. kol. prenosa, vklopite Wi-Fi."</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Operaterjeve meritve porabe podatkov so morda drugačne kot v napravi."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Klic v sili"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Nazaj na klic"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Ime"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Vrsta"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Naslov strežnika"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Šifriranje PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Skrivnost L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifikator IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Ključ v predhodni skupni rabi IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Uporabniško potrdilo IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Overjeno potrdilo IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Potrdilo strežnika IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Prikaži dodatne možnosti"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domene za iskanje DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Strežniki DNS (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Poti za posredovanje (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Uporabniško ime"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Geslo"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Shrani podatke o računu"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(ni uporabljeno)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(ne preveri strežnika)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(prejeto iz strežnika)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Prekliči"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Shrani"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Vzpostavi povezavo"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Urejanje profila VPN"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Povezovanje z <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Dodajanje profila VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Urejanje profila"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Brisanja profila"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Stalno vklopljeno navidez. zaseb. omrež."</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Izberite profil za navidezno zasebno omrežje, s katerim boste vedno povezani. Omrežni promet bo dovoljen samo prek tega navideznega zasebnega omrežja."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Brez"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Za stalno vklopljeno navidezno zasebno omrežje je potreben naslov IP tako za strežnik kot za DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Ni omrežne povezave. Poskusite pozneje."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Ni potrdila. Uredite profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistemska"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Uporabnik"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Onemogoči"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Omogoči"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Odstrani"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Želite omogočiti sistemsko overjeno potrdilo?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Želite onemogočiti sistemsko overjeno potrdilo?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Želite trajno odstraniti uporabniško overjeno potrdilo?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Črkovalnik"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Sem vnesite trenutno geslo za popolno varnostno kopiranje"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Sem vnesite novo geslo za popolno varnostno kopiranje"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Znova vnesite novo geslo za popolno varnostno kopiranje"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Nastavi geslo za varnostno kopijo"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Prekliči"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Dodatne posodobitve sistema"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Onemogočeno"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Dopuščajoče"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Uveljavljajoče"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Omrežje je lahko nadzorovano"</string>
    <string name="done_button" msgid="1991471253042622230">"Končano"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="5339377665264149395">"Nadzor omrežja"</string>
    <string name="ssl_ca_cert_info_message" msgid="4583879256548819713">"To napravo upravlja:\n<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>\n\nSkrbnik lahko nadzira vašo dejavnost v omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij, se obrnite na skrbnika."</string>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Tretja oseba lahko nadzira vašo omrežno dejavnost, vključno z e-poštnimi sporočili, aplikacijami in varnimi spletnimi mesti.\n\nTo ji omogoča zaupanja vredna poverilnica, ki je nameščena v vaši napravi."</string>
    <string name="ssl_ca_cert_settings_button" msgid="8760495070836213605">"Preveri zaupanja vredne poverilnice"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Uporabniki"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Uporabniki in profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Dodajanje uporabnika ali profila"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Dodaj uporabnika"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Omejen profil"</string>
    <string name="user_need_lock_message" msgid="2596365678651842785">"Preden lahko ustvarite profil z omejitvami, morate nastaviti zaklepanje zaslona, da zaščitite aplikacije in osebne podatke."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Nastavi zaklepanje"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Uporabnik ni nastavljen"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Ni nastavljeno – omejen profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Ni nastavljeno – delovni profil"</string>
    <string name="user_owner" msgid="3879126011135546571">"Lastnik"</string>
    <string name="user_you" msgid="1639158809315025986">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Vzdevek"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Dodaj"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Uporabniki imajo svoje aplikacije in vsebino"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Dostop do aplikacij in vsebine iz vašega računa lahko omejite"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Uporabnik"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Omejen profil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Dodajanje novega uporabnika?"</string>
    <string name="user_add_user_message_long" msgid="718192651887726259">"To napravo lahko daste v skupno rabo z drugimi, tako da ustvarite dodatne uporabnike. Vsak ima svoj prostor, ki ga lahko prilagodi z aplikacijami, ozadji in drugim. Uporabniki lahko tudi prilagodijo nastavitve naprave, ki vplivajo na vse, na primer nastavitve omrežja Wi-Fi.\n\nKo dodate novega uporabnika, mora ta nastaviti svoj prostor.\n\nVsak uporabnik lahko posodobi aplikacije za vse druge uporabnike."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Ko dodate novega uporabnika, mora ta nastaviti svoj prostor.\n\nVsak uporabnik lahko posodobi aplikacije za vse druge uporabnike."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Želite uporabnika nastaviti zdaj?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Prepričajte se, da ima oseba čas za nastavitev svojega prostora v napravi"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Želite zdaj nastaviti profil?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Želim nastaviti zdaj"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Ne zdaj"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="8440449301994432789">"Uporabnike lahko upravlja samo lastnik tabličnega računalnika."</string>
    <string name="user_cannot_manage_message" product="default" msgid="1133251987818014757">"Uporabnike lahko upravlja samo lastnik telefona."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Profili z omejitvami ne morejo dodajati računov"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Izbris up. <xliff:g id="USER_NAME">%1$s</xliff:g> iz napr."</string>
    <string name="user_add_on_lockscreen_menu" msgid="3025132738715222247">"Dodajanje uporabnikov, ko je naprava zaklenjena"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Nov uporabnik"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Nov profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Želite izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Odstranitev uporabnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Odstranitev profila?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Želite odstraniti delovni profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="8167855311779740207">"V tem tabličnem računalniku boste izgubili prostor in podatke. Tega dejanja ni mogoče razveljaviti."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5391888073786090274">"V tem telefonu boste izgubili prostor in podatke. Tega dejanja ni mogoče razveljaviti."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Vse aplikacije in vsi podatki bodo izbrisani."</string>
    <string name="work_profile_confirm_remove_message" msgid="7593793549364168783">"Vse aplikacije in podatki v tem profilu bodo izbrisani."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Vse aplikacije in vsi podatki bodo izbrisani."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Dodajanje novega uporabnika ..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Izbriši uporabnika"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Izbriši"</string>
    <string name="user_guest" msgid="8475274842845401871">"Gost"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Odstranitev gosta"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Želite odstraniti gosta?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Vse aplikacije in podatki v tej seji bodo izbrisani."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Odstrani"</string>
    <string name="user_enable_calling" msgid="8310589470979488255">"Omogočanje telefonskih klicev"</string>
    <string name="user_enable_calling_sms" msgid="794823380737672333">"Omogočanje telefonskih klicev in SMS-jev"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Odstranjevanje uporabnika"</string>
    <string name="user_enable_calling_confirm_title" msgid="440218975766968124">"Omogočanje telefonskih klicev?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Zgodovina klicev bo v skupni rabi s tem uporabnikom."</string>
    <string name="user_enable_calling_sms_confirm_title" msgid="188164598768941316">"Omogočanje telefonskih klicev in SMS-jev?"</string>
    <string name="user_enable_calling_sms_confirm_message" msgid="9101983352082865696">"Zgodovina klicev in SMS-jev bo v skupni rabi s tem uporabnikom."</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Omogočanje aplikacij in vsebine"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikacije z omejitvami"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Dodatne nastavitve za aplikacijo"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Odstrani to aplikacijo"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Nastavitve za začetno stran bodo skrite, dokler ne namestite druge aplikacije za začetno stran."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Nastavitev vpliva na vse uporabnike v tem tabličnem računalniku."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Nastavitev vpliva na vse uporabnike v tem telefonu."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Spremenjen jezik"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Spremenjena velikost pisave"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Plačilo z dotikom"</string>
    <string name="google_wallet" msgid="9122936252378589227">"Google Denarnica"</string>
    <string name="nfc_payment_no_apps" msgid="2481080809791416010">"Plačajte z enim dotikom"</string>
    <string name="nfc_payment_favor_foreground" msgid="8881893980929835838">"Daj prednost aplikaciji v ospredju"</string>
    <string name="nfc_payment_learn_more" msgid="5583407773744324447">"Več o tem"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Več ..."</string>
    <string name="nfc_payment_menu_item_add_service" msgid="2885947408068969081">"Iskanje aplikacij"</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Želite nastaviti kot prednostno?"</string>
    <string name="nfc_payment_set_default" msgid="8961120988148253016">"Ali želite za plačilo z dotikom vedno uporabiti aplikacijo <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="3803693771001226795">"Ali želite za plačilo z dotikom namesto aplikacije <xliff:g id="APP_1">%2$s</xliff:g> vedno uporabiti aplikacijo <xliff:g id="APP_0">%1$s</xliff:g>?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Omejitve"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Odstranitev omejitev"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Sprememba kode PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Pokaži obvestila"</string>
    <string name="help_label" msgid="6886837949306318591">"Pomoč in povr. inf."</string>
    <string name="user_account_title" msgid="1127193807312271167">"Račun za vsebino"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografije"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Skrajne grožnje"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Prejem. opozoril o skrajnih grožnjah za življenje in premož."</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Resne grožnje"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Prejem. opozoril o resnih grožnjah za življenje in premož."</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Opozorila AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Prejemanje objav o ugrabitvah otrok"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Ponovitev"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Omogočanje Upravitelja klicev"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Omogoči tej storitvi upravljanje načina izvajanja klicev."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Upravitelj klicev"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2451014351355183338">"Oddaje v sili"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Omrežni operaterji"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Imena dostopnih točk (APN)"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Izboljšan način 4G LTE"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Uporabi prenos podatkov prek LTE za izboljšanje glasu in komunikacij (priporočeno)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Prednostna vrsta omrežja"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (priporočeno)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Delovna kartica SIM"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Dostop do aplikacij in vsebine"</string>
    <string name="user_rename" msgid="8523499513614655279">"PREIMENOVANJE"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Nastavitev omejitev za aplikacijo"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Nadzira aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_not_supported_in_limited" msgid="913035259626149121">"Ta aplikacija ni podprta za profile z omejitvami"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ta aplikacija lahko dostopa do vaših računov"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi-Fi in mobilna omrežja"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Dovoli spreminjanje nastavitev za Wi-Fi in mobilna omrežja"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Dovoli spreminjanje seznanjanj in nastavitev naprav Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Omogoča izmenjavo podatkov, ko se naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dotakne druge naprave NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Dovoli izmenjavo podatkov, ko se tablični računalnik dotakne druge naprave"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Dovoli izmenjavo podatkov, ko se telefon dotakne druge naprave"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Aplikacije lahko uporabljajo podatke o vaši lokaciji"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Nazaj"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Naprej"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Dokončaj"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Posnemi fotografijo"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Izberite fotografijo iz galerije"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Izberite fotografijo"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"Kartici SIM"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"Kartice SIM"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Kartice SIM so spremenjene"</string>
    <string name="sim_cards_changed_message_summary" msgid="5452545583546944683">"Dotaknite se za nastavitev dejavnosti"</string>
    <string name="sim_cellular_data_unavailable" msgid="9018555543451203035">"Prenos podat. v mob. omrež. ni na voljo"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="3654805961942166428">"Dotaknite se, da izberete SIM za prenos podatkov"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Vedno uporabi to možnost za klice"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Izbira kartice SIM za prenos podatkov"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Preklop podatkovne kartice SIM. Lahko traja kakšno minuto …"</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Klicanje z …"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Izberite kartico SIM"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"Kartica SIM je prazna"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Ime kartice SIM"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Vnesite ime kartice SIM"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Reža za SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operater"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Številka"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Barva kartice SIM"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Izberite kartico SIM"</string>
    <string name="color_orange" msgid="4417567658855022517">"Oranžna"</string>
    <string name="color_purple" msgid="3888532466427762504">"Vijolična"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Ni vstavljenih kartic SIM"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Stanje kartice SIM"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Povratni klic s privzete kartice SIM"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"Kartica SIM za odhodne klice"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Druge nastavitve klicev"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"PNO"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Onemog. odd. imena omrež."</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Če onemogočite oddajanje imena omrežja, tretjim osebam onemogočite dostop do podatkov o omrežju."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Če onemogočite oddajanje imena omrežja, preprečite samodejno povezovanje s skritimi omrežji."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<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="6272913297433198340">"Zamenjava kartic SIM."</string>
    <string name="sim_notification_summary" msgid="5024470200658902406">"Dotaknite se za nastavitev"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Prednostna kartica SIM za:"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Vedno vprašaj"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Zahtevana je izbira"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Nastavitve"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Nastavitve"</string>
    <string name="search_menu" msgid="7053532283559077164">"Iskanje"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Nastavitve iskanja"</string>
    <string name="search_recents_queries_label" msgid="2128811638532309069">"Zadnja iskanja"</string>
    <string name="search_results_label" msgid="4163304782363526148">"Rezultati"</string>
    <string name="keywords_wifi" msgid="8947676711698613374">"wifi wi-fi omrežna povezava"</string>
    <string name="keywords_more_default_sms_app" msgid="895656981962034647">"sporočilo SMS pošiljanje sporočil SMS sporočila SMS izmenjava sporočil SMS"</string>
    <string name="keywords_more_mobile_networks" msgid="4939725094449606744">"mobilno mobilni operater brezžični podatki 4G 3G 2G LTE"</string>
    <string name="keywords_wifi_calling" msgid="5497735076883598019">"wifi wi-fi klic klicanje"</string>
    <string name="keywords_home" msgid="3626170808219458848">"zaganjalnik"</string>
    <string name="keywords_display" msgid="6709007669501628320">"zaslon zaslon na dotik"</string>
    <string name="keywords_display_brightness_level" msgid="8923289340474728990">"zatemnitev zaslona zaslon na dotik akumulator"</string>
    <string name="keywords_display_auto_brightness" msgid="8357056338746666901">"zatemnitev zaslona zaslon na dotik akumulator"</string>
    <string name="keywords_display_wallpaper" msgid="6043033055096511751">"ozadje prilagajanje prilagajanje po meri zaslon"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"velikost besedila"</string>
    <string name="keywords_display_cast_screen" msgid="8887412173792143329">"projekt"</string>
    <string name="keywords_storage" msgid="6572905220031852173">"prostor disk trdi disk uporaba naprave"</string>
    <string name="keywords_battery" msgid="2096185085932675704">"poraba energije polnjenje"</string>
    <string name="keywords_spell_checker" msgid="6106749039734174140">"črkovanje slovar preverjanje črkovanja samodejno popravljanje"</string>
    <string name="keywords_voice_input" msgid="3519547605812413860">"prepoznavalnik vnos govor govori jezik prostoročno prosto ročno prepoznavanje žaljivka zvočna zgodovina slušalka bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="392447904221657930">"hitrost jezik privzeto govor govorjenje pretvorba besedila v govor dostopnost bralnik slep"</string>
    <string name="keywords_date_and_time" msgid="2631808108134830066">"vojaška ura"</string>
    <string name="keywords_factory_data_reset" msgid="4355133848707691977">"brisanje izbris obnovitev čiščenje odstranjevanje"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"tiskalnik"</string>
    <string name="keywords_sounds_and_notifications" msgid="5965996187974887000">"pisk zvočnika"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="2912933812460077912">"ne moti prekinjaj prekinitev motnja"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="782326973714313480">"lokacija v bližini zgodovina poročanje"</string>
    <string name="keywords_location_mode" msgid="8584992704568356084">"natančnost"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"račun"</string>
    <string name="keywords_users" msgid="4673901601478559100">"omejitev omeji omejeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="5251531893531063855">"popravljanje besedila pravilno zvok vibriranje samodejno jezik poteza predlaganje predlog tema žaljiva beseda vrsta znak emoji mednarodno"</string>
    <string name="keywords_lockscreen" msgid="4806191868723291541">"podrsanje geslo vzorec pin"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Nastavitev brezžič. oznake NFC"</string>
    <string name="write_tag" msgid="8571858602896222537">"Zapiši"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Dotaknite se oznake za zapisovanje ..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Neveljavno geslo. Poskusite znova."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Uspešno."</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Na oznako NFC ni mogoče zapisati podatkov. Če težave ne odpravite, poskusite z drugo oznako."</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"Na oznako NFC ni mogoče zapisovati. Uporabite drugo oznako."</string>
    <string name="default_sound" msgid="8821684447333687810">"Privzeti zvok"</string>
    <string name="notification_settings" msgid="8791730980212496561">"Zvok in obvestila"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Glasnost predstavnosti"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Glasnost alarma"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Glasnost zvonjenja"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Glasnost obvestila"</string>
    <string name="zen_mode_settings_title" msgid="7014915558669122902">"Prekinitve"</string>
    <string name="zen_mode_option_title" msgid="5061978632306007914">"Ob prejemu klicev in obvestil"</string>
    <string name="zen_mode_option_off" msgid="3167702608910820883">"Vedno prekini"</string>
    <string name="zen_mode_option_important_interruptions" msgid="2320263300561981257">"Dovoli samo prednostne prekinitve"</string>
    <string name="zen_mode_option_no_interruptions" msgid="5664234817617301449">"Ne prekinjaj"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Melodija zvonjenja telefona"</string>
    <string name="notification_ringtone_title" msgid="3361201340352664272">"Privzeti ton zvonjenja za obvestila"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibriranje tudi za klice"</string>
    <string name="notification_section_header" msgid="95661783916799134">"Obvestilo"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Lučka za obvestila z utripanjem"</string>
    <string name="lock_screen_notifications_title" msgid="9118805570775519455">"Ko je naprava zaklenjena"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Pokaži vso vsebino obvestil"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Skrij občutljivo vsebino obvestil"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3001013816427963576">"Ne prikazuj obvestil"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Kako naj se obvestila prikazujejo, ko je naprava zaklenjena?"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Obvestila aplikacij"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Drugi zvoki"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Toni tipkovnice"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvoki ob zaklepanju zaslona"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvok ob odlaganju v nosilec"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvoki dotikov"</string>
    <string name="vibrate_on_touch_title" msgid="674710566941697253">"Vibriranje ob dotiku"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Zvočnik nosilca je vklopljen"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Vsi zvoki"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Samo zvoki predstavnosti"</string>
    <string name="emergency_tone_silent" msgid="1067515631635824291">"Tiho"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Opozorilo"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Vibriranje"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Dostop do obvestil"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikacije ne morejo brati obvestil"</string>
  <plurals name="manage_notification_access_summary_nonzero">
    <item quantity="one" msgid="8344183614159211585">"Aplikacija (%d) lahko bere obvestila"</item>
    <item quantity="other" msgid="980049191810249052">"Aplikacije (%d) lahko berejo obvestila"</item>
  </plurals>
    <string name="no_notification_listeners" msgid="2767405417723149879">"Ni nameščenih poslušalcev obvestil."</string>
    <string name="notification_listener_security_warning_title" msgid="6494221261778885893">"Želite omogočiti <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="2780319203595885564">"Poslušalec <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bo lahko bral vsa obvestila, ki jih objavi sistem ali katera koli nameščena aplikacija, kar lahko vključuje osebne podatke, kot so imena stikov in besedilo sporočil, poslanih vam. Lahko bo tudi opustil ta obvestila ali se dotikal interaktivnih gumbov v njih."</string>
    <string name="manage_condition_providers" msgid="3039306415273606730">"Ponudniki pogojev"</string>
    <string name="manage_condition_providers_summary_zero" msgid="3760902189574984100">"Nobena aplikacija ne ponuja pogojev"</string>
  <plurals name="manage_condition_providers_summary_nonzero">
    <item quantity="one" msgid="7871716594997778198">"%d aplikacija ponuja pogoje"</item>
    <item quantity="other" msgid="358057362115673258">"%d aplikacije ponujajo pogoje"</item>
  </plurals>
    <string name="no_condition_providers" msgid="6183782892066424125">"Ni nameščenih ponudnikov pogojev."</string>
    <string name="condition_provider_security_warning_title" msgid="5834347345913614926">"Želite omogočiti <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="condition_provider_security_warning_summary" msgid="640037330610551763">"Ponudnik pogojev <xliff:g id="CONDITION_PROVIDER_NAME">%1$s</xliff:g> bo lahko dodal pogoje za izhod iz načina »Ne moti«."</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Nalaganje aplikacij ..."</string>
    <string name="app_notification_block_title" msgid="172237877395761371">"Blokiraj"</string>
    <string name="app_notification_block_summary" msgid="9049487483231233726">"Nikoli ne pokaži obvestil za to aplikacijo"</string>
    <string name="app_notification_priority_title" msgid="1967189807102076587">"Prednost"</string>
    <string name="app_notification_priority_summary" msgid="7513344552201639232">"Prikaži obvestila na vrhu seznama in jih prikazuj, ko ima naprava nastavljene samo prednostne prekinitve"</string>
    <string name="app_notification_sensitive_title" msgid="7707233094233553192">"Občutljivo"</string>
    <string name="app_notification_sensitive_summary" msgid="2505314249332316395">"Ko je naprava zaklenjena, skrij občutljivo vsebino v obvestilih za to aplikacijo"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokirano"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prednost"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Občutljivo"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Končano"</string>
    <string name="zen_mode_default_option" msgid="6940069025071935243">"Dokler tega ne izklopite"</string>
    <string name="zen_mode_important_category" msgid="8123274463331022993">"Prednostne prekinitve"</string>
    <string name="zen_mode_downtime_category" msgid="2654477732333340290">"Čas nedelovanja"</string>
    <string name="zen_mode_downtime_days" msgid="3361856902633311616">"Dnevi"</string>
    <string name="zen_mode_downtime_days_none" msgid="8454857121193391322">"Nič"</string>
    <string name="zen_mode_downtime_mode_title" msgid="7249388756365079715">"Motnje so dovoljene"</string>
    <string name="zen_mode_downtime_mode_priority" msgid="1599184173608032994">"Samo prednostno"</string>
    <string name="zen_mode_downtime_mode_none" msgid="8572229891146527069">"Brez"</string>
    <string name="zen_mode_automation_category" msgid="4653551005950835761">"Avtomatizacija"</string>
    <string name="zen_mode_entry_conditions_title" msgid="8467976490601914289">"Samodejni vklop"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="zen_mode_entry_conditions_summary_none" msgid="6589476427475076533">"Nikoli"</string>
    <string name="zen_mode_calls" msgid="7051492091133751208">"Klici"</string>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Sporočila"</string>
    <string name="zen_mode_from" msgid="1033337300289871697">"Klici/sporočila od:"</string>
    <string name="zen_mode_from_anyone" msgid="1180865188673992959">"Vsi"</string>
    <string name="zen_mode_from_contacts" msgid="8751503728985572786">"Samo stiki"</string>
    <string name="zen_mode_from_starred" msgid="2168651127340381533">"Stiki, označeni z zvezdico"</string>
    <string name="zen_mode_events" msgid="2456995649835437565">"Dogodki in opomniki"</string>
    <string name="zen_mode_alarm_info" msgid="3195430795475795398">"Alarmi so vedno prednostne prekinitve"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Samodejni vklop"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikoli"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Vsako noč"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Noči med tednom"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Ura začetka"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Ura konca"</string>
    <string name="zen_mode_end_time_priority_next_day_summary_format" msgid="2910982148167785730">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> naslednji dan"</string>
    <string name="zen_mode_end_time_none_same_day_summary_format" msgid="2002665300812473888">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> ali kateri koli alarm prej"</string>
    <string name="zen_mode_end_time_none_next_day_summary_format" msgid="732719357166551378">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> naslednji dan ali kateri koli alarm prej"</string>
    <string name="notification_settings_apps_title" msgid="1125354590652967250">"Obvestila aplikacij"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Nastavitve obvestil"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Pošlji povratne info. o tej napravi"</string>
    <string name="restr_pin_enter_admin_pin" msgid="2451187374960131018">"Vnesite skrbniški PIN"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Vklopljeno"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Izklopljeno"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Pripenjanje zaslona"</string>
    <string name="screen_pinning_description" msgid="1137904524037468263">"Ko je pripenjanje zaslona vklopljeno, lahko z njim ohranite prikaz trenutnega zaslona, dokler ga ne odpnete.\n\nUporaba prip. zaslona:\n\n1. Pripenjanje zaslona mora biti vklopljeno.\n\n2. Odprite zaslon, ki ga želite pripeti.\n\n3. Dotaknite se tipke za pregled.\n\n4. Povlecite navzgor in se dotaknite ikone žebljička."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Pred odpenjanjem vprašaj za vzorec za odklepanje"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Pred odpenjanjem vprašaj za PIN"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Pred odpenjanjem vprašaj za geslo"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Pri odpenjanju zakleni napravo"</string>
    <string name="managed_user_title" msgid="8101244883654409696">"Delovni profil"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Poskusno)"</string>
    <string name="display_auto_rotate_title" msgid="6176450657107806043">"Ko se naprava zasuka"</string>
    <string name="display_auto_rotate_rotate" msgid="4544299861233497728">"Zasukaj vsebino zaslona"</string>
    <string name="display_auto_rotate_stay_in_portrait" msgid="292745182318093651">"Ohrani pokončni pogled"</string>
    <string name="display_auto_rotate_stay_in_landscape" msgid="3804752830204062162">"Ohrani ležeči pogled"</string>
    <string name="display_auto_rotate_stay_in_current" msgid="317932372686498096">"Ohrani trenutno postavitev"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Podatki o IMEI"</string>
    <string name="encryption_interstitial_header" msgid="5790264941172726485">"Šifriranje"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Naprej"</string>
    <string name="encryption_interstitial_message_pin" msgid="3705622704667901162">"Napravo lahko še dodatno zaščitite, tako da je treba pred zagonom naprave vnesti kodo PIN. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo pomaga pri zaščiti podatkov, če naprave izgubite ali jih ukradejo."</string>
    <string name="encryption_interstitial_message_pattern" msgid="2944051427890104942">"Napravo lahko še dodatno zaščitite, tako da je treba pred zagonom naprave vnesti vzorec. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo pomaga pri zaščiti podatkov, če naprave izgubite ali jih ukradejo."</string>
    <string name="encryption_interstitial_message_password" msgid="1439296580879440802">"Napravo lahko še dodatno zaščitite, tako da je treba pred zagonom naprave vnesti geslo. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo pomaga pri zaščiti podatkov, če naprave izgubite ali jih ukradejo."</string>
    <string name="encrypt_require_pin" msgid="2063945047845243752">"Zahtevanje kode PIN za zagon naprave"</string>
    <string name="encrypt_require_pattern" msgid="6898479411004015810">"Zahtevanje vzorca za zagon naprave"</string>
    <string name="encrypt_require_password" msgid="8770628366276570518">"Zahtevanje gesla za zagon naprave"</string>
    <string name="encrypt_dont_require_pin" msgid="1082444817726247368">"Ne, hvala"</string>
    <string name="encrypt_dont_require_pattern" msgid="6668299362640433843">"Ne, hvala"</string>
    <string name="encrypt_dont_require_password" msgid="2580403214917009046">"Ne, hvala"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Zahtevanje kode PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Zahtevanje vzorca?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Zahtevanje gesla?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="1890374082842868489">"Ko vnesete kodo PIN za zagon te naprave, storitve za osebe s posebnimi potrebami, kot je <xliff:g id="SERVICE">%1$s</xliff:g>, še ne bodo na voljo."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="4474332516537386384">"Ko vnesete vzorec za zagon te naprave, storitve za osebe s posebnimi potrebami, kot je <xliff:g id="SERVICE">%1$s</xliff:g>, še ne bodo na voljo."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="8166099418487083927">"Ko vnesete geslo za zagon te naprave, storitve za osebe s posebnimi potrebami, kot je <xliff:g id="SERVICE">%1$s</xliff:g>, še ne bodo na voljo."</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Podatki o IMEI"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Relativni podatki o IMEI"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Reža <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
</resources>
