<?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">"Nu"</string>
    <string name="create" msgid="3578857613172647409">"Creaţi"</string>
    <string name="allow" msgid="3349662621170855910">"Permiteți"</string>
    <string name="deny" msgid="6947806159746484865">"Refuzați"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Necunoscut"</string>
  <plurals name="show_dev_countdown">
    <item quantity="one" msgid="5295687242294085452">"Mai aveți de parcurs <xliff:g id="STEP_COUNT">%1$d</xliff:g> pas pentru a deveni dezvoltator."</item>
    <item quantity="other" msgid="6722953419953594148">"Mai aveți de parcurs <xliff:g id="STEP_COUNT">%1$d</xliff:g> pași pentru a deveni dezvoltator."</item>
  </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Aţi devenit dezvoltator!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nu mai este nevoie, sunteţi deja dezvoltator."</string>
    <string name="header_category_wireless_networks" msgid="4944823405420438623">"WIRELESS ȘI REȚELE"</string>
    <string name="header_category_device" msgid="5781174212691167553">"DISPOZITIV"</string>
    <string name="header_category_personal" msgid="6225932173498802187">"PERSONAL"</string>
    <string name="header_category_system" msgid="2073558547468647128">"SISTEM"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Porniţi radioul"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Opriţi radioul"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Porniţi SMS prin IMS"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Opriţi SMS prin IMS"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Este necesară activarea înregistrării IMS"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Este necesară dezactivarea înregistrării IMS"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Activaţi imaginea de memorie RAM LTE"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Dezactivaţi imaginea de memorie RAM LTE"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Afişaţi agenda de pe SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Afişaţi numerele fixe de apelare"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Vedeţi numere de apelare de serviciu"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Obţineţi lista PDP"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"În aria de acoperire"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"În afara ariei de acoperire"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Numai apeluri de urgenţă"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Radio oprit"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Nu se utilizează roaming"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Inactiv"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Sună"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Apel în curs"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Deconectată"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Se conectează"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Conectat"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Suspendat"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"necunoscut"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pachete"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"octeţi"</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">"Demontaţi stocarea USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Demontaţi cardul SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Ștergeţi stocarea USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Ștergeţi cardul SD"</string>
    <string name="small_font" msgid="2295331917424072635">"Mică"</string>
    <string name="medium_font" msgid="2068475425515133701">"Medie"</string>
    <string name="large_font" msgid="599055175160971446">"Mare"</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Stocare USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Card SD"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"Stare baterie:"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Cablu de alimentare:"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Scară baterie:"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Nivel baterie:"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"Buna funcţionare a bateriei:"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Tehnologia bateriei:"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Voltaj baterie:"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Temperatură baterie:"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"° C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Durată de la pornire:"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Durată de activitate a bateriei:"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Durată de activitate în timpul încărcării:"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Durata pentru care ecranul este activ:"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Necunoscut"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Încarcă"</string>
    <string name="battery_info_status_charging_ac" msgid="5874340256342956252">"(AC)"</string>
    <string name="battery_info_status_charging_usb" msgid="4059070156126770959">"(USB)"</string>
    <string name="battery_info_status_charging_wireless" msgid="1822125795446772771">"(wireless)"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Nu se încarcă"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Nu încarcă"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Complet"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Deconectat"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"AC"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_wireless" msgid="6819163295739305097">"wireless"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"AC+USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Necunoscut"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Necunoscut"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Bun"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Supraîncălzire"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Epuizată"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Peste voltaj"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Eroare necunoscută"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Golită"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Vizibil pt. dispoz. Bluetooth din aprop. (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Vizibil pt. toate disp. Bluetooth din apropiere"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Nu este vizibil pentru alte dispozitive Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Vizibil numai pe dispozitivele asociate"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Timp limită pentru vizibilitate"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Blocaţi apelarea vocală"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Împiedicaţi apelarea prin Bluetooth când este blocat ecranul"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Dispozitive Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Nume dispozitiv"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Setări dispozitiv"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Setări pentru profil"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nu s-a setat niciun nume, se utilizează numele contului"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Scanaţi pentru a detecta dispozitive"</string>
    <string name="bluetooth_rename_device" product="tablet" msgid="787970073150631155">"Redenumiţi tableta"</string>
    <string name="bluetooth_rename_device" product="default" msgid="6267987985556136749">"Redenumiţi telefonul"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Redenumiţi"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Deconectaţi?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"Astfel se va încheia conexiunea cu:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Dezactivaţi profilul?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"Această acţiune va dezactiva:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;de pe:&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">"Conectat"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Conectat (fără telefon)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Conectat (fără conţ. media)"</string>
    <string name="bluetooth_connected_no_map" msgid="6504436917057479986">"Conectat (fără acces la mesaje)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Conectat (fără tel. sau conţ. media)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Deconectat"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"În curs de deconectare..."</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Se conectează..."</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Se conectează…"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Dispozitiv Bluetooth nedenumit"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Se caută dispozitive"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Nu există disp. Bluetooth în apropiere."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Solicitare de conectare prin Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Solicitare de împerechere"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Atingeţi pentru a împerechea cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Afişaţi fişierele primite"</string>
    <string name="device_picker" msgid="8398232791303186677">"Selector de dispozitive Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Solicitare de permisiune Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="637355677176904990">"O aplicație încearcă să activeze Bluetooth."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"O aplicație încearcă să facă tableta vizibilă pentru alte gadgeturi Bluetooth pentru <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"O aplicație încearcă să facă telefonul vizibil pentru alte gadgeturi Bluetooth pentru <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"O aplicație încearcă să facă tableta vizibilă pentru alte gadgeturi Bluetooth. Puteți modifica ulterior acest lucru din setările Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"O aplicație încearcă să facă telefonul vizibil pentru alte gadgeturi Bluetooth. Puteți modifica ulterior acest lucru din setările Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"O aplicație încearcă să activeze Bluetooth și să facă tableta vizibilă pentru alte gadgeturi pentru <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"O aplicație încearcă să activeze Bluetooth și să facă telefonul vizibil pentru alte gadgeturi pentru <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"O aplicație încearcă să activeze Bluetooth și să facă tableta vizibilă pentru alte gadgeturi. Puteți modifica ulterior acest lucru din setările Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"O aplicație încearcă să activeze Bluetooth și să facă telefonul vizibil pentru alte gadgeturi. Puteți modifica ulterior acest lucru din setările Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Se activează Bluetooth…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Se dezactivează Bluetooth..."</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Conectare automată"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Solicitare de conectare Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Atingeţi pentru a vă conecta la „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>”."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Doriţi să vă conectaţi la „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>”?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Solicitarea accesului la agendă"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s doreşte să acceseze Agenda dvs. şi istoricul apelurilor. Permiteţi accesul pentru %2$s?"</string>
    <string name="bluetooth_remember_choice" msgid="6198284561603824931">"Nu doresc să fiu întrebat(ă) din nou"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Nu doresc să fiu întrebat(ă) din nou"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Solicitarea accesului la mesaje"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s dorește să acceseze mesajele dvs. Oferiți acces pentru %2$s?"</string>
    <string name="date_and_time" msgid="4114084177056654663">"Setări privind data şi ora"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Selectaţi fusul orar"</string>
    <string name="normal_date_format" msgid="7636406984925498359">"Regional (<xliff:g id="DATE">%s</xliff:g>)"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Previzualizaţi:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Dimensiune font:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Trimiteţi <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">"Porniţi <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">"Cont:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Ștergeţi"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Evitaţi utilizarea unui proxy pentru"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com,mycomp.test.com,localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Restabiliţi valorile prestabilite"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Terminat"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Nume de gazdă proxy"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Atenţie"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Numele de gazdă introdus nu este valid."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"Lista de excludere introdusă nu este formatată corect. Introduceţi o listă cu valori separate prin virgulă pentru domeniile excluse."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Trebuie să completaţi câmpul pentru port."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Câmpul pentru port trebuie să fie necompletat în situaţia în care câmpul pentru gazdă este necompletat."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Portul introdus nu este valid."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Proxy-ul HTTP este utilizat de browser, dar nu poate fi utilizat de alte aplicaţii."</string>
    <string name="proxy_url" msgid="2523518669129974654">"Adresa URL a fișierului PAC: "</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Locaţie:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"CID vecin:"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"Informaţii celulă:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Încercări de date:"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"Serviciu GPRS:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Redirecţionare apel:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"Numărul de resetări PPP de la pornire:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"Deconectări GSM:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Reţeaua actuală:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Succese în ceea ce priveşte datele:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"PPP primit:"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"Serviciu GSM:"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Putere semnal:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Stare apel:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"PPP trimis:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Resetări radio:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Mesaj în aşteptare:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Număr de telefon:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Selectaţi banda radio"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Tip de reţea:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Setaţi tipul preferat de reţea:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Daţi comandă ping spre adresa IP:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Daţi comandă ping pentru numele de gazdă (www.google.ro):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"Test client HTTP:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Desfăşuraţi test de comandă ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Actualizaţi"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Actualizaţi"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Activaţi verificarea DNS-ului"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informaţii/Setări caracteristice OEM"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Setaţi banda GSM/UMTS"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Se încarcă lista de benzi..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Setaţi"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Nereuşit"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Reuşit"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Modificările intră în vigoare când se reconectează cablul USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Activaţi stocarea în masă prin USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Număr total de octeţi:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Stocarea USB nu este montată."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Niciun card SD."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Octeţi disponibili:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"Stocare USB utilizată ca dispoz. de stocare masivă."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Cardul SD este utilizat ca dispozitiv de stocare în masă."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"Puteţi elimina stoc. USB în siguranţă"</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"Acum puteţi elimina cardul SD în siguranţă."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"Stoc. USB elimin. în timpul funcţionării!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Cardul SD a fost scos în timp ce era încă utilizat!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Octeţi utilizaţi:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Se scan. stoc. USB pt. media..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Se scanează cardul SD pentru a se identifica fişiere media..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Stoc.USB mont. numai în citire"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Cardul SD montat este numai în citire."</string>
    <string name="skip_label" msgid="47510779345218297">"Omit."</string>
    <string name="next_label" msgid="4693520878012668114">"Înainte"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Limba"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Alegeţi activitatea"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informaţii despre dispozitiv"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Informaţii baterie"</string>
    <string name="display_label" msgid="8074070940506840792">"Ecran"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informaţii tabletă"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informaţii telefon"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Stocare USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Card SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Setări proxy"</string>
    <string name="cancel" msgid="6859253417269739139">"Anulaţi"</string>
    <string name="settings_label" msgid="1626402585530130914">"Setări"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Setări"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Comandă rapidă pentru setări"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Mod Avion"</string>
    <string name="radio_controls_title" msgid="6889937359495515769">"Mai multe..."</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Wireless şi reţele"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Gestionați rețelele Wi-Fi, funcția Bluetooth, modul Avion, rețelele mobile și rețelele VPN"</string>
    <string name="roaming" msgid="3596055926335478572">"Roaming de date"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Conectaţi-vă la servicii de date în roaming"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Conectaţi-vă la serviciile de date în roaming"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Aţi pierdut conectivitatea la date deoarece aţi părăsit reţeaua de domiciliu neavând activat roamingul."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Activaţi"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Când permiteţi roamingul de date puteţi acumula taxe considerabile pentru roaming!"</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Dacă permiteţi roamingul de date, puteţi acumula cheltuieli considerabile pentru roaming!\n\nAceastă setare afectează toţi utilizatorii de pe această tabletă."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Dacă permiteţi roamingul de date, puteţi acumula cheltuieli considerabile pentru roaming!\n\nAceastă setare afectează toţi utilizatorii de pe acest telefon."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Permiteţi roamingul de date?"</string>
    <string name="networks" msgid="6333316876545927039">"Selectarea operatorului"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Alegeţi un operator de reţea"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Data şi ora"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Setaţi data şi ora"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Setaţi data, ora, fusul orar şi formatele."</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Dată şi oră automate"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Utilizaţi ora furnizată de reţea"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Utilizaţi ora furnizată de reţea"</string>
    <string name="zone_auto" msgid="334783869352026648">"Fus orar automat"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Utilizaţi fusul orar furnizat de reţea"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Utilizaţi fusul orar furnizat de reţea"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Utilizaţi formatul de 24 de ore"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Setaţi ora"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Selectaţi un fus orar"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Setaţi data"</string>
    <string name="date_time_date_format" msgid="6951498879879281102">"Alegeţi formatul de dată"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Sortaţi în ordine alfabetică"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Sortaţi după fusul orar"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Data"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Ora"</string>
    <string name="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Îmbunătățiți recunoașterea feței"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Verificare mișcare"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Se solicită clipirea la deblocare"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Blocare automată"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> după inactivitate"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Afişaţi info. proprietar la blocarea ecranului"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Info. proprietar"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Activați widgeturi"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Setare dezactivată de administrator"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Introduceţi textul de afişat pe ecranul de blocare"</string>
    <string name="show_user_info_on_lockscreen_label" msgid="8408914624925608365">"Informații utilizator pe ecranul de blocare"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Info. utilizator"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Afișați informații profil la blocarea ecranului"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Informații profil"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Locație"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Securitate"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Setaţi Locaţia mea, deblocarea ecranului, blocarea cardului SIM, blocarea stocării acreditărilor"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Setaţi Locaţia mea, deblocarea ecranului, blocarea stocării acreditărilor"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Parole"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Criptare"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Criptaţi tableta"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Criptaţi telefonul"</string>
    <string name="crypt_keeper_encrypt_summary" product="tablet" msgid="6291564408810586">"Necesită un cod PIN numeric sau o parolă de decriptare a tabletei la fiecare pornire a acesteia"</string>
    <string name="crypt_keeper_encrypt_summary" product="default" msgid="514138079795442371">"Necesită un cod PIN numeric sau o parolă de decriptare a telefonului la fiecare pornire a acestuia"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Criptat"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="3839235202103924154">"Puteţi să criptaţi conturi, setări, aplicaţii descărcate şi datele acestora, fişiere media şi alte tipuri de fişiere. După criptarea tabletei, trebuie să introduceţi un cod PIN numeric sau o parolă pentru a o decripta de fiecare dată când o porniţi. Nu puteţi decripta tableta decât prin resetarea configurării din fabrică, ceea ce va şterge toate datele de pe aceasta.\n\nCriptarea poate dura cel puţin o oră. Trebuie să începeţi cu o baterie încărcată şi să ţineţi tableta conectată până la finalizarea criptării. Întreruperea procesului de criptare poate duce la pierderea tuturor datelor sau a unor părţi din acestea."</string>
    <string name="crypt_keeper_desc" product="default" msgid="7663118199519229502">"Puteţi să criptaţi conturi, setări, aplicaţii descărcate şi datele acestora, fişiere media şi alte tipuri de fişiere. După criptarea telefonului, trebuie să introduceţi un cod PIN numeric sau o parolă pentru a-l decripta de fiecare dată când îl porniţi. Nu puteţi decripta telefonul decât prin resetarea configurării din fabrică, ceea ce va şterge toate datele de pe acesta.\n\nCriptarea poate dura cel puţin o oră. Trebuie să începeţi cu o baterie încărcată şi să ţineţi telefonul conectat până la finalizarea criptării. Întreruperea procesului de criptare poate duce la pierderea tuturor datelor sau a unor părţi din acestea."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Criptaţi tableta"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Criptaţi telefonul"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Încărcaţi bateria şi încercaţi din nou."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Conectaţi încărcătorul şi încercaţi din nou."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Nu există un cod PIN sau o parolă pentru blocarea ecranului"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Trebuie să setaţi un cod PIN sau o parolă pentru blocarea ecranului înainte de a începe criptarea."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Criptaţi?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Operaţia de criptare este ireversibilă şi întreruperea ei va duce la pierderea datelor. Criptarea durează cel puţin o oră, timp în care tableta se va reporni de mai multe ori."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="5682944380460921880">"Operaţia de criptare este ireversibilă şi întreruperea ei va duce la pierderea datelor. Criptarea durează cel puţin o oră, timp în care telefonul se va reporni de mai multe ori."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Criptare"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Aşteptaţi criptarea tabletei. Finalizat <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Aşteptaţi criptarea telefonului. Finalizat <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_cooldown" msgid="685210918307862395">"Încercaţi din nou peste <xliff:g id="DELAY">^1</xliff:g> (de) secunde."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Introduceţi parola"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Criptare nereuşită"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Criptarea a fost întreruptă şi nu se poate finaliza. Prin urmare, datele de pe tableta dvs. nu mai sunt accesibile. \n\nPentru a relua utilizarea tabletei, trebuie să efectuaţi o resetare la valorile din fabrică. Când configuraţi tableta după resetare, veţi putea restabili toate datele pentru care aţi creat copii de rezervă în Contul Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3083477162766772532">"Criptarea a fost întreruptă şi nu se poate finaliza. Prin urmare, datele de pe telefonul dvs. nu mai sunt accesibile. \n\nPentru a relua utilizarea telefonului, trebuie să efectuaţi o resetare la valorile din fabrică. Când configuraţi telefonul după resetare, veţi putea restabili toate datele pentru care aţi creat copii de rezervă în Contul Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Comutaţi metoda de introducere"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Alegeţi blocare ecran"</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Aleg. blocare rezervă"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Blocarea ecranului"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Schimbaţi bloc.ecran."</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Modificaţi sau dezactivaţi modelul, codul PIN sau siguranţa prin parolă"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Alegeţi o metodă pentru a bloca ecranul"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Când funcţia Deblocare facială nu vă poate vedea, cum doriţi să deblocaţi?"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Fără"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="2871898266296656162">"Glisare"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Fără securitate"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Deblocare facială"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Securitate minimă, experimental"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Model"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Securitate medie"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Nivel de securitate mediu spre ridicat"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Parolă"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Securitate ridicată"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Dezactivată de admin./politică de criptare/date de conectare"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Fără"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5660014471997663139">"Glisare"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Deblocare facială"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Model"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Parolă"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Activaţi blocarea ecranului"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Eliminaţi modelul pentru deblocare"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Eliminaţi codul PIN de deblocare"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Eliminaţi parola de deblocare"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Schimbaţi modelul pentru deblocare"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Schimbaţi codul PIN de deblocare"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Schimbaţi parola pentru deblocare"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Parola trebuie să conţină minimum %d (de) caractere"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"Codul PIN trebuie să aibă minimum %d cifre"</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Atingeţi Continuaţi la terminare"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Continuaţi"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Parola trebuie să aibă mai puţin de <xliff:g id="NUMBER">%d</xliff:g> (de) caractere."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"Codul PIN trebuie să aibă mai puţin de <xliff:g id="NUMBER">%d</xliff:g> (de) cifre."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"Codul PIN trebuie să conţină numai cifre de la 0 la 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"Administr. dispoz. nu permite utiliz. unui PIN recent."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Parola conţine un caracter nepermis."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Parola trebuie să conţină cel puţin o literă."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Parola trebuie să conţină minimum o cifră."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Parola trebuie să conţină cel puţin un simbol."</string>
  <plurals name="lockpassword_password_requires_letters">
    <item quantity="one" msgid="3063853802158131458">"Parola trebuie să conţină cel puţin 1 literă."</item>
    <item quantity="other" msgid="8186027808415585970">"Parola trebuie să conţină cel puţin %d litere."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Parola trebuie să conţină cel puţin 1 minusculă."</item>
    <item quantity="other" msgid="2693910942679679225">"Parola trebuie să conţină cel puţin %d minuscule."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Parola trebuie să conţină cel puţin 1 majusculă."</item>
    <item quantity="other" msgid="3030801209112209245">"Parola trebuie să conţină cel puţin %d majuscule."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Parola trebuie să conţină cel puţin 1 cifră."</item>
    <item quantity="other" msgid="4703982391407595924">"Parola trebuie să conţină cel puţin %d cifre."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Parola trebuie să conţină cel puţin 1 simbol special."</item>
    <item quantity="other" msgid="1221290525051187757">"Parola trebuie să conţină cel puţin %d simboluri speciale."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Parola trebuie să conţină cel puţin 1 caracter care să nu fie o literă."</item>
    <item quantity="other" msgid="3952508584649046404">"Parola trebuie să conţină cel puţin %d caractere care să nu fie litere."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Administrator dispozitiv nu permite parolă recentă."</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"OK"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Anulaţi"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Anulaţi"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Înainte"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Configurarea este completă."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Administrarea dispozitivelor"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Administratori dispozitiv"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Afişaţi sau dezactivaţi administratorii dispozitivului"</string>
    <string name="manage_notification_access" msgid="5799781079264981979">"Acces la notificări"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplicațiile nu pot citi notificările"</string>
  <plurals name="manage_notification_access_summary_nonzero">
    <item quantity="one" msgid="8344183614159211585">"%d aplicație poate citi notificările"</item>
    <item quantity="other" msgid="980049191810249052">"%d aplicații pot citi notificările"</item>
  </plurals>
    <string name="no_notification_listeners" msgid="2767405417723149879">"Nu sunt instalate aplicații de citire a notificărilor."</string>
    <string name="notification_listener_security_warning_title" msgid="6494221261778885893">"Activați <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="2780319203595885564">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> va putea să citească toate notificările postate de sistem sau de aplicațiile instalate, care ar putea include informații personale, cum ar fi numele persoanelor de contact și textul mesajelor care vă sunt trimise. De asemenea, va putea să închidă aceste notificări sau să atingă butoanele de acțiuni din cadrul acestora."</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Activaţi funcţia 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">"Gestionaţi conexiunile, setaţi numele dispozitivului şi detectabilitatea acestuia"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Solicitare de împerechere prin Bluetooth"</string>
    <string name="bluetooth_enter_pin_msg" msgid="5698297871117529185">"Pentru împerecherea cu:<xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Introduceţi codul PIN necesar al dispozitivului:"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="2220143735340367939">"Pentru împerecherea cu:<xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Introduceţi cheia de acces necesară a dispozitivului:"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Codul PIN conţine litere sau simboluri"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"De obicei, 0000 sau 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Ar putea fi necesar, de asemenea, să introduceţi acest cod PIN pe celălalt dispozitiv."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Ar putea fi necesar, de asemenea, să introduceţi această parolă pe celălalt dispozitiv."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Pentru asocierea cu:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;asiguraţi-vă că se afişează această cheie de acces:&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">"De la:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Asociaţi cu acest dispozitiv?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Pentru împerecherea cu:<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>Introduceţi pe acesta:<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>, apoi apăsaţi tasta Return sau Enter."</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Asociaţi"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Anulaţi"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Nu s-a putut împerechea cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Nu s-a putut împerechea cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> din cauza unui cod PIN sau al unei chei de acces incorecte."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Nu se poate comunica cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Împerechere respinsă de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Nu s-a putut conecta la <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Scanaţi pentru a detecta dispozitive"</string>
    <string name="bluetooth_search_for_devices" msgid="5957007154213560390">"Căutaţi dispozitive"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Se caută..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Setările dispozitivului"</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Dispozitive împerecheate"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Dispozitive disponibile"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Conectaţi-vă"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Deconectaţi"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Asociaţi şi conectaţi"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Anulaţi împerecherea"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Deconectaţi şi anulaţi împerecherea"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Opţiuni…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Avansate"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Setări Bluetooth avansate"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Activarea Bluetooth permite comunicarea cu alte dispozitive Bluetooth din apropiere."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Conectaţi-vă la..."</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Conţinut media audio"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Componenta audio a telefonului"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Transfer de fişiere"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Dispozitiv de intrare"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Acces internet"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Distribuirea conexiunii la internet"</string>
    <string name="bluetooth_profile_map" msgid="5465271250454324383">"Acces la mesaje"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> va fi deconectat de la media audio."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> va fi deconectat de la componenta audio handsfree."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> va fi deconectat de la dispozitivul de intrare."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Va fi întrerupt accesul la internet prin <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="5455448395850929200">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> va fi deconectat de la conexiunea acestui telefon la internet."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5266851881175033601">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> va fi deconectat de la conexiunea acestui telefon la internet."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Dispozitiv Bluetooth asociat"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Conectaţi-vă"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Conectaţi-vă la dispozitivul Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="3764437426089639639">"Profiluri"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Redenumiţi"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Permiteţi transfer fişiere"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"Conectat la profilul pentru conţinut media audio"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Conectat la componenta audio a telefonului"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Conectat la serverul de transfer de fişiere"</string>
    <string name="bluetooth_map_profile_summary_connected" msgid="8191407438851351713">"Conectat la hartă"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Neconectat la serverul de transfer de fişiere"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Conectat la dispozitivul de intrare"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Conectat la disp. pt. acces internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Se perm. disp. acces la internet local"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Utilizaţi pentru profilul pentru conţinut media audio"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Utilizaţi pentru componenta audio a telefonului"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Utilizaţi pentru transferul de fişiere"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Utilizaţi pentru introducere date"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Utilizaţi pentru acces internet"</string>
    <string name="bluetooth_map_profile_summary_use_for" msgid="5154200119919927434">"Utilizați pentru hartă"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Setări de andocare"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Utilizaţi dispozitivul de andocare pentru componenta audio"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Ca difuzor"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Pentru muzică şi fişiere media"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Reţineţi setările"</string>
    <string name="wifi_display_settings_title" msgid="2925465988657380522">"Ecran de trimitere"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Activați ecranul wireless"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Nu s-au găsit dispozitive în apropiere."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Se conectează"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Conectat"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Se utilizează"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Indisponibil"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Setări de afişare"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Opțiuni pentru ecrane wireless"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Eliminaţi"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Terminat"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Nume"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Permiteţi schimbul de date atunci când tableta atinge alt dispozitiv"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Permiteţi schimbul de date atunci când telefonul atinge alt dispozitiv"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Pregătit să transmită conţinut din aplicaţii prin NFC"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Dezactivată"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Indisponibilă, deoarece NFC este oprit"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"După activarea acestei funcţii, puteţi transmite conţinutul aplicaţiilor către un alt dispozitiv compatibil NFC, ţinând cele două dispozitive apropiate unul de celălalt. De exemplu, puteţi să transmiteţi pagini din browser, videoclipuri YouTube, persoane din agendă şi multe altele.\n\nNu trebuie decât să apropiaţi cele două dispozitive (de obicei, aşezându-le unul în spatele celuilalt) şi să atingeţi ecranul. Aplicaţia determină apoi ce poate fi transmis."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Descoperire serviciu de reţea"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Permite aplicaţiilor de pe alte dispozitive să descopere aplicaţii pe acest dispozitiv"</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Activați conexiunea Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Setări Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Configuraţi şi gestionaţi punctele de acces wireless"</string>
    <string name="wifi_setup_wizard_title" msgid="8242230950011819054">"Selectați o rețea Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Se activează Wi-Fi…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Se dezactivează Wi-Fi…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Eroare"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"În modul Avion"</string>
    <string name="wifi_fail_to_scan" msgid="1265540342578081461">"Nu se poate scana pentru reţele"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Notificare de reţea"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3038290727701553612">"Anunță-mă când este disponibilă o rețea deschisă"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Evitaţi conexiunile slabe"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7843672905900544785">"Nu utilizați o reţea Wi-Fi, cu excepția cazului în care aceasta are o conexiune la internet adecvată"</string>
    <string name="wifi_scan_always_available" msgid="3470564139944368030">"Scanare mereu disponibilă"</string>
    <string name="wifi_scan_always_available_summary" msgid="7768204638882691453">"Permiteți serviciului de localizare Google și altor aplicații să caute rețele, chiar dacă rețeaua Wi-Fi este dezactivată"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instalați certificate"</string>
    <string name="wifi_scan_notify_text_location_on" msgid="8135076005488914200">"Pentru a îmbunătăți precizia locației, dar și în alte scopuri, Google și alte aplicații pot căuta rețele în apropiere, chiar dacă rețeaua Wi-Fi este dezactivată. Dacă nu doriți acest lucru, accesați Avansate &gt; Scanare mereu disponibilă."</string>
    <string name="wifi_scan_notify_text_location_off" msgid="6323983741393280935">"Aplicațiile pot căuta rețele în apropiere, chiar dacă rețeaua Wi-Fi este dezactivată. Dacă nu doriți acest lucru, accesați Avansate &gt; Scanare mereu disponibilă."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="5340097010842405981">"Nu mai afișa"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Mențineți Wi-Fi activat în modul inactiv"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"A apărut o problemă la modificarea setării"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizare Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Reduceți la minimum utilizarea bateriei când rețeaua Wi-Fi este activată"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Adăugaţi o reţea"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Rețele Wi-Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Buton WPS"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Mai multe opţiuni"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Introduceţi PIN WPS"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi-Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Scanaţi"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Avansate"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Conectaţi-vă la reţea"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Eliminaţi reţeaua"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modificaţi reţeaua"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Vedeți rețelele disponibile activând Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Se caută rețele Wi-Fi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="8280257225419947565">"Nu aveți permisiunea să modificați rețeaua Wi‑Fi."</string>
    <string name="wifi_other_network" msgid="1048006316504242214">"Altă reţea…"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Mai multe"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Config. automată (WPS)"</string>
    <string name="wifi_required_info_text" msgid="4080969509965288881">"Pentru a finaliza configurarea, este necesar ca tableta să aibă acces la Wi-Fi. După configurare, puteți opta să utilizați datele mobile sau Wi-Fi."</string>
    <string name="wifi_show_advanced" msgid="1793703023711426246">"Afişaţi opţiunile avansate"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Configurare protejată Wi-Fi"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Se porneşte WPS…"</string>
    <string name="wifi_wps_onstart_pbc" msgid="5940801028985255304">"Apăsați butonul Configurare protejată Wi-Fi de pe router. Acesta poate apărea ca „WPS” sau poate conține acest simbol:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Introduceți codul PIN <xliff:g id="NUMBER">%1$s</xliff:g> pe routerul Wi-Fi. Finalizarea configurării poate dura până la două minute."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"WPS finalizată. Se conectează la reţea…"</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Conectat la rețeaua Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"WPS este deja în desfăşurare. Finalizarea poate dura până la două minute."</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"WPS eşuată. Încercaţi din nou peste câteva minute."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Setarea de securitate pentru routerul wireless (WEP) nu este acceptată"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Setarea de securitate pentru routerul wireless (TKIP) nu este acceptată"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Autentificare eşuată. Încercaţi din nou."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"A fost detectată altă sesiune WPS. Încercaţi din nou peste câteva minute."</string>
    <string name="wifi_ssid" msgid="641393708309146745">"SSID reţea"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Introduceți identificatorul SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Securitatea"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Putere semnal"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Stare"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Viteză"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Adresă IP"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Metodă EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Autentificare faza 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certificat CA"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certificat de utilizator"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identitate"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Identitate anonimă"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Parolă"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Afişaţi parola"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Setări IP"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(neschimbate)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(neindicat)"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"Salvată"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Dezactivată"</string>
    <string name="wifi_disabled_network_failure" msgid="3111321240793227690">"S-a evitat o conexiune de internet slabă"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Problemă la autentificare"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"În afara ariei de acoperire"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS disponibil"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS disponibil)"</string>
    <string name="wifi_secured_first_item" msgid="4072076186051083451">"Securizată cu <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_secured_second_item" msgid="1326000076939056265">", securizată cu <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Niciuna"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Pentru a îmbunătăți precizia locației, precum și pentru alte scopuri, <xliff:g id="APP_NAME">%1$s</xliff:g> solicită permisiunea să activeze scanarea rețelelor, chiar și atunci când rețeaua Wi-Fi este dezactivată.\n\nPermiteți acest lucru pentru toate aplicațiile care solicită scanarea?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Permiteți"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Respingeți"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Conectaţi-vă"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Nu s-a putut stabili conexiunea la reţea"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Eliminaţi"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Nu s-a putut elimina reţeaua"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Salvaţi"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Nu s-a putut salva reţeaua"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Anulaţi"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Ignoraţi oricum"</string>
    <string name="wifi_dont_skip" msgid="7350341524881124808">"Nu ignoraţi"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="3335132188969450252">"AVERTISMENT: puteţi acumula costuri suplimentare pentru date de la operator.\n\nConfigurarea tabletei poate presupune o activitate semnificativă în reţea."</string>
    <string name="wifi_skipped_message" product="default" msgid="1192848364146401759">"AVERTISMENT: puteţi acumula costuri suplimentare pentru date de la operator.\n\nConfigurarea telefonului poate presupune o activitate semnificativă în reţea."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="6161024589991810940">"AVERTISMENT: tableta nu va putea verifica actualizarea software-ului decât după ce aveți o conexiune de internet."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="3773473163264984767">"AVERTISMENT: telefonul nu va putea verifica actualizarea software-ului decât după ce aveți o conexiune de internet."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Tableta nu s-a putut conecta la această rețea Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefonul nu s-a putut conecta la această rețea Wi-Fi."</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Setări Wi-Fi avansate"</string>
    <string name="wifi_setting_frequency_band_title" msgid="3655327399028584656">"Bandă de frecvență Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Indicaţi intervalul de frecvenţă al operaţiei"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"A apărut o probl. la setarea benzii de frecvenţă."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresă MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresă IP"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Setări IP"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Salvaţi"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Anulaţi"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Introduceţi o adresă IP validă."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Introduceţi o adresă gateway validă."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Introduceţi o adresă DNS validă."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Introduceţi prefix reţea din 0 – 32 caractere."</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">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Lungime prefix reţea"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informaţii dispozitiv"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Reţineţi această conexiune"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Căutaţi dispozitive"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Se caută…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Redenumiţi dispozitivul"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Împerecheaţi dispozitivele"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Grupuri reţinute"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Conectarea nu s-a putut realiza."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Dispozitivul nu a fost redenumit."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Deconectaţi?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Dacă vă deconectaţi, conexiunea cu <xliff:g id="PEER_NAME">%1$s</xliff:g> se va încheia."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Dacă vă deconectaţi, conexiunea cu <xliff:g id="PEER_NAME">%1$s</xliff:g> şi cu alte <xliff:g id="PEER_COUNT">%2$s</xliff:g> dispozitive se va încheia."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Anulaţi invitaţia?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Doriţi să anulaţi invitaţia de conectare cu <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Eliminaţi acest grup?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Hotspot Wi-Fi portabil"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Se activează hotspotul..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Se dezactivează hotspotul..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Hotspot portabil <xliff:g id="NETWORK_SSID">%1$s</xliff:g> activ"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Eroare de hotspot Wi-Fi portabil"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Configurați hotspotul Wi-Fi"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"Hotspot Wi-Fi portabil <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="home_settings" msgid="212375129455718176">"Ecran de pornire"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Afişare"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Sunet"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Ton de apel al telefonului"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Volumele"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Efecte muzicale"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Volum sonerie"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibrează la profilul Silenţios"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Sunet de notificare prestabilit"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Indicator luminos intermitent"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Ton de apel"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Notificare"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Utilizaţi volumul apelurilor de intrare pentru notificări"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Sunet de notificare prestabilit"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Media"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Setaţi volumul pentru muzică şi videoclipuri"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarmă"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Setări audio pentru dispozitivul de andocare ataşat"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tonuri atingere taste"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Sunete la atingere"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Sunet de blocare a ecranului"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Vibrare la atingere"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Anulare zgomot"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muzică, videoclipuri, jocuri şi alt conţinut media"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Ton de sonerie şi notificări"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Notificări"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarme"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Dezactivaţi sunetul pentru tonul de sonerie şi notificări"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Dezactivaţi sunetul muzicii şi al altui conţinut media"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Dezactivaţi sunetul notificărilor"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Dezactivaţi sunetul alarmelor"</string>
    <string name="vibrate_when_ringing_title" msgid="3885857358303178029">"Vibrează când sună"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Andocare"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Setări de andocare"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Setări pentru dispozitivul de andocare al desktopului ataşat"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Setări pentru dispozitivul de andocare al maşinii ataşat"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tableta nu este andocată"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefonul nu este andocat"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Setări pentru dispozitivul de andocare ataşat"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Dispozitivul de andocare nu a fost găsit"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Trebuie să andocaţi tableta înainte de configurarea dispozitivului de andocare audio."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Trebuie să andocaţi telefonul înainte de configurarea dispozitivului de andocare audio."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Sunet de inserare în dispozitivul de andocare"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Doresc să se redea sunet la inserarea sau scoaterea tabletei din dispozitivul de andocare"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Redaţi sunet la introducerea sau la scoaterea telefonului din dispozitivul de andocare"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"Nu doresc să se redea sunet la inserarea sau scoaterea tabletei din dispozitivul de andocare"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"Nu redaţi sunetul la introducerea şi la scoaterea telefonului din dispozitivul de andocare"</string>
    <string name="account_settings" msgid="6403589284618783461">"Conturi"</string>
    <string name="search_settings" msgid="1910951467596035063">"Căutaţi"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Gestionaţi setările şi istoricul căutărilor"</string>
    <string name="display_settings" msgid="7965901687241669598">"Afişare"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Rotire automată a ecranului"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Doresc comutarea automată a orientării atunci când se roteşte tableta"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Schimbaţi automat orientarea la rotirea telefonului"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Doresc comutarea automată a orientării atunci când se roteşte tableta"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Doresc schimbarea automată a orientării la rotirea telefonului"</string>
    <string name="brightness" msgid="2354961343555249270">"Luminozitate"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Ajustaţi luminozitatea ecranului"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Inactivitate"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"După <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inactivitate"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Imagine de fundal"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Alege o imagine din"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Daydream"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Când dispozitivul este andocat sau în modul inactiv şi se realizează încărcarea"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"În ambele situații"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"În timpul încărcării"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Când dispozitivul este andocat"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Dezactivat"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Pentru a controla ceea ce se întâmplă când telefonul este andocat şi/sau în modul inactiv, activaţi Daydream."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Când porneşte Daydreams"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Începeţi acum"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Setări"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Luminozitate automată"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Dimensiune font"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Dimensiune font"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Setări de blocare a cardului SIM"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Activaţi blocarea cardului SIM"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Blocare card SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Blocaţi cardul SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Utilizarea tabletei necesită un cod PIN"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Solicitaţi codul PIN pentru utilizarea telefonului"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Utilizarea tabletei necesită un cod PIN"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Solicitaţi codul PIN pentru utilizarea telefonului"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Schimbaţi codul PIN pentru SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"PIN SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Blocaţi cardul SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Deblocaţi cardul SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Vechiul cod PIN al cardului SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nou cod PIN pentru SIM"</string>
    <string name="sim_reenter_new" msgid="3178510434642201544">"Reintroduceţi noul cod PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"PIN SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Cod PIN incorect"</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"Codurile PIN nu corespund"</string>
    <string name="sim_change_failed" msgid="304964924772218382">"Nu se poate schimba codul PIN.\nCodul PIN poate fi incorect."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Codul PIN pentru SIM a fost modificat"</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"Nu se poate modifica starea de blocare a cardului SIM.\nCodul PIN poate fi incorect."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Anulaţi"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Codul PIN pentru cardul SIM este incorect. Contactați operatorul pentru a vă debloca dispozitivul."</string>
  <plurals name="wrong_pin_code">
    <item quantity="one" msgid="4840607930166101114">"Codul PIN pentru cardul SIM este incorect. V-a mai rămas <xliff:g id="NUMBER">%d</xliff:g> încercare, după care va trebui să contactați operatorul pentru a vă debloca dispozitivul."</item>
    <item quantity="other" msgid="77103619544346451">"Codul PIN pentru cardul SIM este incorect. V-au mai rămas <xliff:g id="NUMBER">%d</xliff:g> încercări."</item>
  </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Deblocarea cu ajutorul codului PIN pentru cardul SIM nu a reușit!"</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Stare tabletă"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Stare telefon"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Actualizări de sistem"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Versiune Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Număr model"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID echipament"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Versiunea benzii de bază"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Versiune nucleu"</string>
    <string name="build_number" msgid="3075795840572241758">"Numărul versiunii"</string>
    <string name="selinux_status" msgid="6212165375172061672">"Stare SELinux"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Indisponibil"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Stare"</string>
    <string name="device_status" msgid="607405385799807324">"Stare"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Starea bateriei, reţeaua şi alte informaţii"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Număr de telefon, semnal etc."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Stocare"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Setări de stocare"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Demontaţi stocarea USB, afişaţi stocarea disponibilă"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Demontaţi cardul SD, afişaţi spaţiul de stocare disponibil"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Numărul meu de telefon"</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">"Versiune PRL"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="3279383550222116235">"Tip de reţea mobilă"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informații operator"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Starea reţelei mobile"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Starea acoperirii"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Putere semnal"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Reţea"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresă MAC Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresă Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Număr de serie"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Indisponibilă"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Durată de funcţionare"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Durată de activitate"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Stocare internă"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Stocare USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Card SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"Disponibil"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Disponibil (numai în citire)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Spaţiu total"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Se calculează..."</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Aplicații (date și conținut media)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Media"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Descărcări"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Imagini, videoclipuri"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Audio (muzică, tonuri de sonerie, podcasturi etc.)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Diverse"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Datele memorate în cache"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Demontaţi stoc. distrib."</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Demontaţi cardul SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Demontaţi stocarea USB internă"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Demontaţi cardul SD, pentru a-l putea elimina în siguranţă"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Inser. stoc. USB pt. montare"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Introduceţi un card SD pentru montare"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Montaţi stocarea USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Montaţi cardul 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">"Ștergeţi stocarea USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Ștergeţi cardul SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Șterge toate datele din stocarea USB internă, cum ar fi muzica şi fotografiile"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Șterge toate datele de pe cardul SD, cum ar fi muzica şi fotografiile"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Ștergeţi datele memorate în cache?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Datele din cache ale aplicaţiilor vor fi şterse."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funcţia MTP sau PTP este activă"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Demontaţi stocarea USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Demontaţi cardul SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Dacă demontaţi stocarea USB, unele aplicaţii pe care le utilizaţi se vor opri şi ar putea fi nedisponibile până la remontarea stocării USB."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Dacă demontaţi cardul SD, unele aplicaţii utilizate în acel moment se vor opri şi pot fi indisponibile până la remontarea cardului 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">"Stocarea USB nu a putut fi demontată. Încercaţi din nou mai târziu."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"Nu se poate demonta cardul SD. Încercaţi din nou mai târziu."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Dispozitivul de stocare USB va fi demontat."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Cardul SD va fi demontat."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"În curs de demontare"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Demontare în curs"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Spaţiu de stocare aproape ocupat"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Este posibil ca unele funcţii de sistem, cum ar fi sincronizarea, să nu funcţioneze corect. Încercaţi să eliberaţi spaţiu, ştergând elemente sau anulând fixarea acestora (de ex., aplicaţii sau conţinut media)."</string>
    <string name="storage_menu_usb" msgid="5708207885333243384">"Conectare la computer prin USB"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Conectare la computer prin USB"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Conectaţi-vă ca"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Dispozitiv media (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Vă permite să transferaţi fişiere media pe Windows sau utilizând aplicaţia Transfer de fişiere Android pe Mac (disponibil la www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Cameră foto (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"Vă permite să transferaţi fotografii utilizând software-ul camerei foto şi să transferaţi fişiere de pe computere care nu acceptă MTP"</string>
    <string name="usb_label_installer_cd" msgid="4331173824920630215">"Instalaţi instrumentul de transfer al fişierelor"</string>
    <string name="storage_other_users" msgid="808708845102611856">"Alţi utilizatori"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Stare baterie"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Nivelul bateriei"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Nume APN"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Modificaţi punctul de acces"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nesetat"</string>
    <string name="apn_name" msgid="4115580098369824123">"Nume"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Nume de utilizator"</string>
    <string name="apn_password" msgid="5412301994998250968">"Parolă"</string>
    <string name="apn_server" msgid="2436185314756372858">"Server"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Proxy MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Port MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Tip de autentificare"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Niciunul"</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 sau CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Tip APN"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protocol APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protocol de roaming APN"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Activaţi/dezactivaţi APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN activat"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN dezactivat"</string>
    <string name="bearer" msgid="594270280031923558">"Purtător"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Tip MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Valoare MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Ștergeţi APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"APN nou"</string>
    <string name="menu_save" msgid="8109345640668285399">"Salvaţi"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Renunţaţi"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Câmpul Nume nu poate fi necompletat."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"Numele APN nu poate fi necompletat."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Câmpul MCC trebuie să conţină 3 cifre."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Câmpul MNC trebuie să conţină 2 sau 3 cifre."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Se restabilesc setările APN prestabilite."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Resetaţi la valorile prestabilite"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Resetarea setărilor APN prestabilite a fost finalizată."</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Resetarea configurării din fabrică"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Șterge toate datele de pe tabletă"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Șterge toate datele de pe telefon"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"Această acţiune va şterge toate datele din "<b>"stocarea internă"</b>" a tabletei dvs., inclusiv:\n\n"<li>"Contul dvs. Google;"</li>\n<li>"datele şi setările sistemului şi ale aplicaţiilor;"</li>\n<li>"aplicaţiile descărcate."</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"Această acţiune va şterge toate datele din "<b>"stocarea internă"</b>" a telefonului dvs., inclusiv:\n\n"<li>"Contul dvs. Google;"</li>\n<li>"datele şi setările sistemului şi ale aplicaţiilor;"</li>\n<li>"aplicaţiile descărcate."</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"În prezent sunteţi conectat(ă) la următoarele conturi:\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Muzică"</li>\n<li>"Fotografii"</li>\n<li>"Alte date ale utilizatorului"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Pentru a şterge muzică, imagini şi alte date ale utilizatorului, "<b>"stocarea USB"</b>" trebuie să fie ştearsă."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Pentru a şterge muzică, imagini şi alte date ale utilizatorului, "<b>"cardul SD"</b>" trebuie să fie şters."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Ștergeţi stocarea USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Ștergeţi cardul SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Ștergeţi toate datele din stocarea USB internă, cum ar fi muzica sau fotografiile"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Ștergeţi toate datele de pe cardul SD, cum ar fi muzica sau fotografiile"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Resetaţi tableta"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Resetaţi telefonul"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Ștergeţi toate informaţiile personale şi aplicaţiile descărcate? Nu puteţi anula această acţiune!"</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Ștergeţi tot"</string>
    <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Desenaţi modelul pentru deblocare"</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Trebuie să desenaţi modelul de deblocare pentru a confirma resetarea configurării din fabrică."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Nu a fost efectuată nicio resetare, deoarece serviciul Golire sistem nu este disponibil."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Resetaţi?"</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Ștergeţi stocarea USB"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Ștergeţi cardul SD"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Șterge datele din stocarea USB"</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Ștergeţi toate datele de pe cardul SD"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Ștergeţi integral stocarea USB? Veţi pierde "<b>"toate"</b>" datele stocate!"</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Ștergeţi cardul SD? Veţi pierde "<b>"toate"</b>" datele de pe card!"</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Ștergeţi stocarea USB"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Ștergeţi cardul SD"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Ștergeţi stocarea USB şi toate fişierele stocate pe aceasta? Nu puteţi anula această acţiune!"</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Ștergeţi cardul SD şi toate fişierele stocate pe acesta? Acţiunea nu poate fi anulată!"</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Ștergeţi tot"</string>
    <string name="media_format_gesture_prompt" msgid="3109349468816856670">"Desenaţi modelul pentru deblocare"</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"Trebuie să desenaţi modelul de deblocare pentru a confirma că doriţi să ştergeţi stocarea USB."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"Trebuie să desenaţi modelul de deblocare pentru a confirma că doriţi să ştergeţi cardul SD."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Setări apel"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Activaţi mesageria vocală, redirecţionarea apelurilor, apelul în aşteptare, ID apelant"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Tethering prin USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Hotspot portabil"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Tethering prin Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Tethering"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Tethering şi hotspot portabil"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Tethering prin USB"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"USB conectat, verificaţi pentru distribuirea de internet"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Se utilizează pentru distribuirea de internet"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Nu se poate conecta ca modem când se utilizează stocarea USB"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"USB neconectat"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Eroare de tethering prin USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Tethering prin Bluetooth"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Se permite acces la conexiunea internet a tabletei"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Se permite acces la conex. internet a telefonului"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Se permite acces la conex. internet a tabletei pt. 1 disp."</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Se permite acces la conex. internet a telef. pt. 1 disp."</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Se permite acces la conex.internet a tabletei pt. <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> disp."</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Se permite acces la conex. internet a telef. pt. <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> disp."</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Nu se permite acces la conex. internet a tabletei"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Nu se perm. acces la conex. internet a telefonului"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Nu este conectat ca modem"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"Este imposibil tethering cu peste <xliff:g id="MAXCONNECTION">%1$d</xliff:g> dispozitive."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> va fi deconectat."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Ajutor"</string>
    <string name="network_settings_title" msgid="7967552516440151852">"Reţele mobile"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Plan de date mobile"</string>
    <string name="sms_application_title" msgid="6134351177937015839">"Aplicație SMS prestabilită"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Schimbați aplicația SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Utilizați <xliff:g id="NEW_APP">%1$s</xliff:g> în loc de <xliff:g id="CURRENT_APP">%2$s</xliff:g> ca aplicație SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Utilizați <xliff:g id="NEW_APP">%s</xliff:g> ca aplicație SMS?"</string>
    <string name="mobile_unknown_sim_operator" msgid="9101230468757324260">"Operator de SIM necunoscut"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"Niciun site de provizionare cunoscut pentru %1$s"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Introduceți cartela SIM și reporniți"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Conectați-vă la internet"</string>
    <string name="location_title" msgid="1029961368397484576">"Locaţia mea"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Mod"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Precizie ridicată"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Economisirea bateriei"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Numai pe dispozitiv"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Locație dezactivată"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Solicitări recente de localiz."</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Nicio aplicație nu a solicitat locația recent"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Servicii de localizare"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Utilizarea intensă a bateriei"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Utilizarea redusă a bateriei"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Mod de localizare"</string>
    <string name="location_mode_high_accuracy_description" msgid="6418936349431602808">"Utilizează GPS-ul și rețelele Wi-Fi și mobile pentru determinarea locației"</string>
    <string name="location_mode_battery_saving_description" msgid="1728668969743485109">"Utilizează rețelele Wi-Fi și mobile pentru determinarea locației"</string>
    <string name="location_mode_sensors_only_description" msgid="7178415350457794366">"Utilizează GPS-ul pentru determinarea locației"</string>
    <string name="location_loading_injected_setting" msgid="4238574500081976654">"Se efectuează preluarea…"</string>
    <string name="location_network_based" msgid="9134175479520582215">"Localizare prin Wi-Fi și mobil"</string>
    <string name="location_neighborhood_level" msgid="5626515380188353712">"Aplicaţiile estimează mai rapid locaţia cu serviciul de localizare Google. Se colectează/trimit la Google date anonime de localizare."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Locație stabilită prin Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Sateliţi GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Permiteţi aplicaţiilor să utilizeze GPS de pe tabletă pentru a indica locaţia dvs."</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Permiteţi aplicaţiilor să utilizeze GPS de pe telefon pentru a indica locaţia dvs."</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Utilizaţi GPS asistat"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Utilizaţi serverul pentru a asista funcţia GPS (debifaţi pentru a reduce utilizarea reţelei)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Utilizaţi serverul pentru a asista funcţia GPS (debifaţi pentru a îmbunătăţi performanţa GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Locaţie şi căutare Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Permiteţi Google să utilizeze locaţia dvs. pt. îmbunăt. rezultatelor căutării şi serviciilor"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Acces la locaţia dvs."</string>
    <string name="location_access_summary" msgid="69031404093194341">"Acordaţi aplicaţiilor care v-au solicitat, permisiunea să utilizeze informaţiile dvs. de localizare"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Surse de locaţii"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Despre tabletă"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Despre telefon"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Afişaţi informaţii legale, starea şi versiunea programului software"</string>
    <string name="legal_information" msgid="5769301644270604095">"Informaţii de ordin juridic"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Colaboratori"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Informaţii reglementare"</string>
    <string name="copyright_title" msgid="865906688917260647">"Drept de autor"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenţă"</string>
    <string name="terms_title" msgid="7697580845616764642">"Termeni şi condiţii"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Licenţe open source"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"A apărut o problemă la încărcarea licenţelor."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Se încarcă…"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informaţii privind siguranţa"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informaţii privind siguranţa"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Nu aveţi o conexiune de date. Pentru a vedea aceste informaţii acum, accesaţi %s de pe orice computer conectat la internet."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Se încarcă…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Alegeţi parola"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Alegeţi modelul"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Alegeţi codul PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Confirmaţi parola"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Confirmaţi modelul"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Confirmaţi codul PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Parolele nu corespund"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"Codurile PIN nu corespund"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Select. metoda de deblocare"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Parola a fost setată"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Codul PIN a fost setat"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Modelul a fost setat"</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Siguranţa ecranului"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Schimbaţi modelul pentru deblocare"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Schimbaţi codul PIN de deblocare"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Confirmaţi modelul salvat"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Încercaţi din nou:"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Desenaţi un model pentru deblocare"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Apăsaţi pe Meniu pentru ajutor."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Ridicaţi degetul când aţi terminat"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Conectaţi cel puțin <xliff:g id="NUMBER">%d</xliff:g> puncte. Încercaţi din nou."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Model înregistrat"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Desenaţi din nou modelul pentru a confirma"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Noul dvs. model pentru deblocare"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Confirmaţi"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Redesenare"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Încercaţi din nou"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Continuaţi"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Model pentru deblocare"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Solicitaţi model"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Trebuie să desenaţi modelul pentru a debloca ecranul"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Faceţi modelul vizibil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Vibrare la atingere"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Bloc. inst. cu buton pornire"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Setaţi modelul pentru deblocare"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Schimbaţi modelul pentru deblocare"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Modul de desenare a unui model de deblocare"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Prea multe încercări incorecte!"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Încercaţi din nou peste <xliff:g id="NUMBER">%d</xliff:g> (de) secunde."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplicaţia nu este instalată pe telefonul dvs."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Gestionaţi aplicaţii"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Gestionaţi şi eliminaţi aplicaţiile instalate"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Aplicaţii"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Gestionaţi aplicaţii, creaţi comenzi rapide pentru lansare rapidă"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Setări aplicaţii"</string>
    <string name="install_applications" msgid="4872012136210802181">"Surse necunoscute"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Permiteţi instalarea aplicaţiilor din surse necunoscute"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Tableta şi datele dvs. personale sunt mai vulnerabile la un atac din partea aplicaţiilor ce provin din surse necunoscute. Sunteţi de acord că sunteţi singura persoană responsabilă pentru deteriorarea tabletei sau pierderea datelor ce pot avea loc ca urmare a utilizării acestor aplicaţii."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Telefonul şi datele dvs. personale sunt mai vulnerabile la un atac din partea aplicaţiilor ce provin din surse necunoscute. Sunteţi de acord că sunteţi singura persoană responsabilă pentru deteriorarea telefonului sau pierderea datelor ce pot avea loc ca urmare a utilizării acestor aplicaţii."</string>
    <string name="verify_applications" msgid="2959359554974828518">"Verificaţi aplicaţiile"</string>
    <string name="verify_applications_summary" msgid="6737505521913263792">"Respingeţi sau avertizaţi înainte de instalarea unor aplicaţii care pot cauza daune"</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Setări avansate"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Activaţi mai multe opţiuni pentru setări"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informaţii despre aplicaţie"</string>
    <string name="storage_label" msgid="8700867073480107253">"Stocare"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Lansaţi în mod prestabilit"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Prestabilite"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Compatibilitate ecran"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Permisiuni"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Memorie cache"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Goliţi memoria cache"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Memorie cache"</string>
    <string name="controls_label" msgid="7611113077086853799">"Comenzi"</string>
    <string name="force_stop" msgid="7435006169872876756">"Opriţi forţat"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Total"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Aplicaţie"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Stocare aplicaţie pe USB"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Date"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Stocare date pe USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Card SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Dezinstalaţi"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Dezinstalaţi pentru toţi utilizatorii"</string>
    <string name="install_text" msgid="884360662922471113">"Instalaţi"</string>
    <string name="disable_text" msgid="6544054052049395202">"Dezactivaţi"</string>
    <string name="enable_text" msgid="9217362512327828987">"Activaţi"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Ștergeţi datele"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Dezinstalaţi actualizările"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Aţi ales să lansaţi această aplicaţie în mod prestabilit pentru anumite acţiuni."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Aţi ales să permiteţi acestei aplicaţii să creeze widgeturi şi să acceseze datele acestora."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nu este setată nicio valoare standard."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Ștergeţi valorile standard"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Este posibil ca această aplicaţie să nu fie proiectată pentru ecranul dvs. Aici puteţi stabili modul în care aceasta se adaptează ecranului dvs."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Se stabileşte la lansare"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Scalaţi aplicaţia"</string>
    <string name="unknown" msgid="1592123443519355854">"Necunoscut"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Sortaţi după nume"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Sortaţi după dimensiune"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Serviciile care rulează"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Procese memorie cache"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Resetați preferințe aplicații"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Resetați preferințele pentru aplicații?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Aceasta va reseta toate preferințele pentru:\n\n "<li>"aplicații dezactivate;"</li>\n" "<li>"notificări de aplicații dezactivate;"</li>\n" "<li>"aplicații prestabilite pentru acțiuni;"</li>\n" "<li>"restricții privind datele de fundal pentru aplicații;"</li>\n" "<li>"orice restricții de permisiuni."</li>\n\n" Nu veți pierde datele aplicațiilor."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Resetaţi aplicaţiile"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Gestionaţi spaţiul"</string>
    <string name="filter" msgid="2018011724373033887">"Filtraţi"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Alegeţi opţiunile de filtrare"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Toate"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Dezactivate"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Descărcate"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Rulează"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Stocare USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Pe cardul SD"</string>
    <string name="disabled" msgid="9206776641295849915">"Dezactivată"</string>
    <string name="not_installed" msgid="1475144352069281880">"Neinstalată"</string>
    <string name="no_applications" msgid="7336588977497084921">"Nu există aplicaţii."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Stocare internă"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Stocare USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Stocare card SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Se recalculează dimensiunea..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Ștergeţi datele aplicaţiei?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Toate datele acestei aplicaţii vor fi şterse definitiv. Aici sunt incluse toate fişierele, setările, conturile, bazele de date etc."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Anulaţi"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"Aplicaţia nu a fost găsită în lista de aplicaţii instalate."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Nu s-au putut şterge datele aplicaţiei."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Dezinstalaţi actualizările?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Toate actualizările aduse acestei aplicaţii de sistem Android vor fi dezinstalate."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Ștergeţi datele"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Nu s-au putut şterge datele aplicaţiei."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Această aplicaţie poate accesa pe tabletă următoarele:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Această aplicaţie poate accesa următoarele elemente de pe telefonul dvs.:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Această aplicaţie poate accesa următoarele elemente pe tableta dvs. Pentru a îmbunătăţi performanţa şi a reduce consumul de memorie, unele dintre aceste permisiuni sunt disponibile pentru <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, deoarece aceasta rulează în acelaşi proces ca şi <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Această aplicaţie poate accesa următoarele elemente pe telefonul dvs. Pentru a îmbunătăţi performanţa şi a reduce consumul de memorie, unele dintre aceste permisiuni sunt disponibile pentru <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, deoarece aceasta rulează în acelaşi proces ca şi <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> şi <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> şi <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Această aplicaţie poate să genereze costuri:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Trimiteţi SMS premium"</string>
    <string name="computing_size" msgid="1599186977475211186">"În curs de calculare..."</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Nu s-a putut calcula mărimea pachetului."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Nu aveţi instalată nicio aplicaţie terţă parte."</string>
    <string name="version_text" msgid="9189073826278676425">"versiunea <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Mutaţi"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Mutaţi pe tabletă"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Mutaţi în telefon"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Mutaţi în stocarea USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Mutaţi pe cardul SD"</string>
    <string name="moving" msgid="6431016143218876491">"Se deplasează"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nu există suficient spaţiu de stocare."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"Aplicaţia nu există."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplicaţia este protejată la copiere."</string>
    <string name="invalid_location" msgid="2786030127356312746">"Locaţia de instalare nu este validă."</string>
    <string name="system_package" msgid="6222593098063037137">"Actualizările de sistem nu pot fi instalate pe suportul extern."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Opriţi forţat?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Dacă forţaţi oprirea unei aplicaţii, aceasta se poate comporta necorespunzător."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Aplicaţia nu a putut fi mutată. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Locaţie preferată de instalare"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Schimbaţi locaţia preferată de instalare pentru noile aplicaţii"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Dezactiv. aplic. încorporată?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Dacă dezactivaţi o aplicaţie încorporată, este posibil ca alte aplicaţii să se comporte necorespunzător."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Ștergeţi datele şi dezactivaţi aplicaţia?"</string>
    <string name="app_special_disable_dlg_text" msgid="3447657419284854195">"Dacă dezactivaţi o aplicaţie încorporată, este posibil ca alte aplicaţii să funcţioneze incorect. Datele dvs. vor fi, de asemenea, şterse."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Dezactivaţi notificările?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Dacă dezactivaţi notificările pentru această aplicaţie, puteţi pierde alerte şi actualizări importante."</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Operații ale aplicației"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Rulează"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nu este utilizată niciodată)"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Utilizare stocare"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Afişaţi stocarea utilizată de aplicaţii"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Servicii în curs de funcţionare"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Vedeţi şi controlaţi serviciile care funcţionează în prezent"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Reporneşte"</string>
    <string name="cached" msgid="1059590879740175019">"Proces de fundal în memoria cache"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nu rulează niciun serv."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Iniţiat de aplicaţie"</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> liberi"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> utilizați"</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">"Utilizator: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Utilizator eliminat"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces şi <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviciu"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces şi <xliff:g id="NUMSERVICES">%2$d</xliff:g> (de) servicii"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> (de) procese şi <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviciu"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> (de) procese şi <xliff:g id="NUMSERVICES">%2$d</xliff:g> (de) servicii"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Aplicaţia care rulează"</string>
    <string name="no_services" msgid="7133900764462288263">"Nu există servicii active"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Servicii"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procese"</string>
    <string name="service_stop" msgid="6369807553277527248">"Opriţi"</string>
    <string name="service_manage" msgid="1876642087421959194">"Setări"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Acest serviciu a fost pornit de propria aplicaţie. Oprirea serviciului poate duce la eşuarea aplicaţiei."</string>
    <string name="heavy_weight_stop_description" msgid="2979218727598321095">"Această aplicaţie nu poate fi oprită în siguranţă. Oprirea aplicaţiei ar putea duce la pierderea datelor curente."</string>
    <string name="background_process_stop_description" msgid="5034773197139654588">"Acesta este un proces al unei aplicaţii mai vechi, care rulează în continuare, pentru cazul în care este necesar din nou. De obicei nu există niciun motiv să îl opriţi."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: se află în prezent în utilizare. Atingeţi Setări pentru a controla serviciul."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Procesul principal în uz."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Serviciul <xliff:g id="COMP_NAME">%1$s</xliff:g> se află în utilizare."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Furnizorul <xliff:g id="COMP_NAME">%1$s</xliff:g> se află în utilizare."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Opriţi serviciul sistemului?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Dacă opriţi acest serviciu, este posibil ca unele funcţii ale tabletei să nu mai funcţioneze corect decât după ce o veţi închide şi redeschide."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Dacă opriţi acest serviciu, este posibil ca unele funcţii ale telefonului să nu mai funcţioneze corect decât după ce îl veţi închide şi redeschide."</string>
    <string name="language_settings" msgid="5292716747264442359">"Limbă și introducere de text"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Limbă și introducere de text"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Setări de limbă"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tastatură şi introducere de text"</string>
    <string name="phone_language" msgid="8870144109924299673">"Limba"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Înlocuire automată"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Corectaţi cuvintele scrise greşit"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Scriere automată cu majuscule"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Scrieţi cu literă mare prima literă din propoziţii"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Se introduce automat punctuaţia"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Setări pentru tastatura fizică"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Apăsaţi de două ori pe tasta de spaţiu pentru a insera „.”"</string>
    <string name="show_password" msgid="3001113966880559611">"Faceţi parolele vizibile"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Această metodă de introducere de text poate culege în întregime textul introdus, inclusiv datele personale, cum ar fi parolele şi numerele cardurilor de credit. Metoda provine de la aplicaţia <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Utilizaţi această metodă de introducere de text?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Acest instrument de verificare a ortografiei poate, de asemenea, să culeagă în întregime textul pe care îl introduceţi, inclusiv datele personale, cum ar fi parolele şi numerele cardurilor de credit. Instrumentul provine de la aplicaţia <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Utilizaţi acest instrument de verificare ortografică?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Setări"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Limbă"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Deschiderea setărilor pentru <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g> a eşuat"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Mouse/trackpad"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Viteza indicatorului"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Controler de joc"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Utilizaţi mecanismul de vibrare"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Redirecţionaţi mecanismul de vibrare pentru controlerul de joc când este conectat."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Alegeţi aspectul tastaturii"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Configuraţi aspectele tastaturii"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Pentru comutare, apăsaţi pe Control-Space"</string>
    <!-- no translation found for keyboard_layout_default_label (2952672513543482165) -->
    <skip />
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Aspecte tastatură"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Dicționar personal"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Adăugaţi"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Adăugaţi în dicţionar"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Expresie"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Mai multe opţ."</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Mai puţine opţ."</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Cuvânt:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Comandă rapidă:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Limbă:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Introduceți un cuvânt"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Comandă rapidă opțională"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Modificaţi cuvântul"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Modificaţi"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Ștergeţi"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"Nu există cuvinte în dicţionarul utilizatorului. Puteţi adăuga un cuvânt atingând butonul Adăugaţi (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Pentru toate limbile"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Mai multe limbi..."</string>
    <string name="testing" msgid="6584352735303604146">"Testare"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informaţii tabletă"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informaţii telefon"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Informaţii baterie"</string>
    <string name="quick_launch_title" msgid="7904609846945905306">"Lansare rapidă"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Setaţi comenzi rapide de la tastatură pentru a lansa aplicaţii"</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Atribuiţi o aplicaţie"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Fără comandă rapidă"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Căutaţi + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Ștergeţi"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Comanda dvs. rapidă pentru <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) va fi ştearsă."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"OK"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Anulaţi"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Aplicaţii"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Comenzi rapide"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Introducere text"</string>
    <string name="input_method" msgid="5434026103176856164">"Metodă de intrare"</string>
    <string name="current_input_method" msgid="234072873286056438">"Prestabilit"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Selector al metodei de intrare"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automat"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Afişaţi întotdeauna"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Ascundeţi întotdeauna"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Setaţi metode de introducere text"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Setări"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Setări"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Metode active de introducere de text"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Utilizaţi limba sistemului"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Setări <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Alegeţi metode de intrare active"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Setări pentru tastatura de pe ecran"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Tastatură fizică"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Setări pentru tastatura fizică"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Opţiuni dezvoltator"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Setaţi opţiuni pentru dezvoltarea aplicaţiei"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Opțiunile de dezvoltator nu sunt disponibile pentru acest utilizator"</string>
    <string name="enable_adb" msgid="7982306934419797485">"Depanare USB"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Mod de depanare când este conectat USB"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Revoc autorizații depanare USB"</string>
    <string name="bugreport_in_power" msgid="4548816486587403971">"Raport erori în meniul de pornire"</string>
    <string name="bugreport_in_power_summary" msgid="5764234382355067053">"Includeţi în meniul de pornire opţiunea de a executa un raport despre erori"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Activ permanent"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Ecranul nu va fi inactiv pe durata încărcării"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Activați jurnalul de examinare HCI Bluetooth"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Înregistrați toate pachetele HCI Bluetooth într-un fișier"</string>
    <string name="select_runtime_title" msgid="649783802363155346">"Select. mediul de execuție"</string>
    <string name="select_runtime_dialog_title" msgid="5314872813037493958">"Select. mediul de execuție"</string>
    <string name="select_runtime_warning_message" msgid="1937574953265648165">"Reporniți pentru a schimba mediul de execuție de la <xliff:g id="OLD">%1$s</xliff:g> la <xliff:g id="NEW">%2$s</xliff:g>?"</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Certificare Ecran wireless"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Afișați opțiunile pentru certificarea Ecran wireless"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Permiteţi locaţiile fictive"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Permiteţi locaţiile fictive"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Permiteţi depanarea USB?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Depanarea USB are exclusiv scopuri de dezvoltare. Utilizaţi-o pentru a copia date de pe computer pe dispozitiv, pentru a instala aplicaţii pe dispozitiv fără notificare şi pentru a citi datele din jurnale."</string>
    <string name="adb_keys_warning_message" msgid="6932230298032192937">"Revocați accesul la remedierea erorilor prin USB de pe toate computerele pe care le-ați autorizat anterior?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Permiteţi setările pentru dezvoltare?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Aceste setări sunt destinate exclusiv utilizării pentru dezvoltare. Din cauza lor, este posibil ca dispozitivul dvs. şi aplicaţiile de pe acesta să nu mai funcţioneze sau să funcţioneze necorespunzător."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Verificaţi aplicaţiile prin USB"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Verificaţi aplicaţiile instalate utilizând ADB/ADT, pentru a detecta un comportament dăunător."</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Protejaţi stocarea USB"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Aplicaţiile trebuie să ceară permisiunea de a citi stocarea USB"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Protejaţi stocarea USB?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Când stocarea USB este protejată, aplicaţiile trebuie să solicite permisiunea de a citi datele de pe stocarea externă.\n\nEste posibil ca unele aplicaţii să nu funcţioneze înainte de a fi actualizate de către dezvoltatorii lor."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Protejaţi cardul SD"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Aplicaţiile trebuie să ceară permisiunea de a citi cardul SD"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Protejaţi cardul SD?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Când cardul SD este protejat, aplicaţiile trebuie să solicite permisiunea de a citi datele de pe stocarea externă.\n\nEste posibil ca unele aplicaţii să nu funcţioneze înainte de a fi actualizate de către dezvoltatorii lor."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Aplicație terminal locală"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Activați aplicația terminal care oferă acces la shell local"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Alegeţi obiectul gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Alegeţi obiectul widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Creaţi widgetul şi permiteţi accesul?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"După ce creaţi widgetul, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> poate accesa toate datele pe care acesta le afişează."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Permiteţi întotdeauna ca <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> să creeze widgeturi şi să acceseze datele acestora"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> z <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> sec."</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g>z <xliff:g id="HOURS">%2$d</xliff:g>h <xliff:g id="MINUTES">%3$d</xliff:g>m"</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>m"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g>m"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistici de utilizare"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistici de utilizare"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Sortaţi după:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplicaţie"</string>
    <string name="launch_count_label" msgid="4019444833263957024">"Numărul total"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Durată de utilizare"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Accesibilitate"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Setări de accesibilitate"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Servicii"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Sistem"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Subtitrări"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Gesturi pentru mărire"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2380627654189671754">"După activarea acestei funcţii, puteţi mări şi micşora atingând de trei ori ecranul.\n\nÎn timp ce măriţi, puteţi:\n"<ul><li>"să deplasaţi: deplasaţi două sau mai multe degete pe ecran;"</li>\n<li>"să ajustaţi nivelul de zoom: ciupiţi cu două sau mai multe degete ori îndepărtați-le."</li></ul>\n\n"De asemenea, puteţi să măriţi temporar ce se află sub degetul dvs. atingând ecranul de trei ori şi menţinând degetul pe ecran. În imaginea mărită, puteţi să glisaţi degetul pentru a explora diferite părţi ale ecranului. Ridicaţi degetul pentru a reveni la starea anterioară.\n\nNotă: atingerea triplă pentru mărire funcţionează peste tot, cu excepţia tastaturii şi a barei de navigare."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Comandă rapidă de accesibilitate"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Activat"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Dezactivată"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"După activarea acestei funcţii, puteţi să activaţi rapid funcţiile de accesibilitate în doi paşi:\n\nPasul 1: apăsaţi şi menţineţi apăsat butonul de pornire până când auziţi un sunet sau simţiţi o vibraţie.\n\nPasul 2: atingeţi ecranul cu două degete şi menţineţi degetele pe ecran până când auziţi o confirmare audio.\n\nDacă gadgetul are mai mulţi utilizatori, folosirea acestei comenzi rapide pe ecranul de blocare activează temporar accesibilitatea până când gadgetul este deblocat."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Text mare"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Mărirea ecranului"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Actualizaţi auto. mărirea ecranului"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Actualiz. mărirea ecran. la tranziţia între aplic."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Butonul de pornire închide"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Rostiţi parolele"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Întârziere la atingere continuă"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Setări"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Activată"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Dezactivată"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Previzualizați"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Opțiuni standard"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Limbă"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Dimensiunea textului"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Stilul subtitrării"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Opțiuni personalizate"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Culoare de fundal"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Opacitatea fundalului"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Culoarea textului"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Opacitatea textului"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Culoarea marginii"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Tipul marginii"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Familie de fonturi"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Subtitrările vor arăta așa"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Prestabilit"</string>
    <string name="color_none" msgid="3475640044925814795">"Niciuna"</string>
    <string name="color_white" msgid="8045195170201590239">"Alb"</string>
    <string name="color_gray" msgid="9192312087142726313">"Gri"</string>
    <string name="color_black" msgid="7517353520909872561">"Negru"</string>
    <string name="color_red" msgid="4949354900304125428">"Roșu"</string>
    <string name="color_green" msgid="5537717328428845841">"Verde"</string>
    <string name="color_blue" msgid="7731984529016953223">"Albastru"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cyan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Galben"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Magenta"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Utilizați <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> are funcțiile:"</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Remarcă acțiunile dvs."</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="2095111008854376237">"Primește notificări atunci când interacționați cu o aplicație."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Opriți <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2012273739481042318">"Atingând OK veți opri <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nu există servicii instalate"</string>
    <string name="accessibility_service_no_apps_title" msgid="5124097563864109821">"Aveţi nevoie de un cititor de ecran?"</string>
    <string name="accessibility_service_no_apps_message" msgid="7751662416377046539">"Serviciul TalkBack oferă feedback vocal pentru a ajuta utilizatorii nevăzători şi cu probleme de vedere. Doriţi să îl instalaţi în mod gratuit din Android Market?"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nu a fost furnizată o descriere."</string>
    <string name="settings_button" msgid="3006713718908152930">"Setări"</string>
    <string name="print_settings" msgid="4742428530112487843">"Printare"</string>
    <string name="print_settings_title" msgid="3685449667822217816">"Servicii de imprimare"</string>
    <string name="print_service_security_warning_title" msgid="2338435517408144841">"Utilizați <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="print_service_security_warning_summary" msgid="7567131958613064363">"Documentul poate trece prin unul sau mai multe servere pe calea spre imprimantă."</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nu există servicii instalate"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nu au fost găsite imprimante"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Setări"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Adăugați imprimante"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Activată"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Dezactiv."</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Adăugați un serviciu"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Adăugați o imprimantă"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Căutați"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Se caută imprimante"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Serviciu dezactivat"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Sarcini de printare"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Sarcină de printare"</string>
    <string name="print_restart" msgid="8373999687329384202">"Reporniți"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Anulaț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">"Se printează <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Se anulează <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Eroare de printare: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Printare blocată: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Caseta de căutare este afișată"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Caseta de căutare este ascunsă"</string>
  <plurals name="print_search_result_count_utterance">
    <item quantity="one" msgid="1322401991353603285">"<xliff:g id="COUNT">%1$s</xliff:g> imprimantă găsită"</item>
    <item quantity="other" msgid="460211409510874128">"<xliff:g id="COUNT">%1$s</xliff:g> (de) imprimante găsite"</item>
  </plurals>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Battery"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Ce funcţii au utilizat bateria"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Date utilizare baterie nedisp."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Utilizarea bateriei de la deconectare"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Utilizarea bateriei de la resetare"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> pe baterie"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> de la deconectare"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Se încarcă"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Ecran activat"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS activat"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Utilizată"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Semnal reţea mobilă"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Durată de activitate a dispozitivului"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Timp de funcționare Wi-Fi"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Timp de funcționare Wi-Fi"</string>
    <string name="usage_name_percent" msgid="7976919382448235858">"<xliff:g id="NAME">%1$s</xliff:g> -  <xliff:g id="NUMBER">%2$s</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Detalii istoric"</string>
    <string name="details_title" msgid="3792801565213935385">"Detalii despre utilizare"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Detalii despre utilizare"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Ajustaţi utilizarea de energie"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Pachete incluse"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ecran"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Aşteptare celulă"</string>
    <string name="power_phone" msgid="5392641106474567277">"Apeluri vocale"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tableta inactivă"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon inactiv"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Total procesor"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"Procesor în prim plan"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Păstrare în activitate"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Funcționare Wi-Fi"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tabletă"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="3875198715268918671">"Date mobile trimise"</string>
    <string name="usage_type_data_recv" msgid="6694951443404021754">"Date mobile primite"</string>
    <string name="usage_type_data_wifi_send" msgid="7178327382353096029">"Date Wi-Fi trimise"</string>
    <string name="usage_type_data_wifi_recv" msgid="7822328607564241372">"Date Wi-Fi primite"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Durată de activitate"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Durată fără semnal"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Opriţi forţat"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informaţii despre aplicaţie"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Setări aplicaţii"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Setări ecran"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Setări Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Setări Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Baterie utilizată de apelurile vocale"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Baterie utilizată când tableta este inactivă"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Baterie utilizată când telefonul este inactiv"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Baterie utilizată de radio celular"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Comutaţi la modul Avion pentru a economisi energia în zonele fără acoperire celulară"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Baterie utilizată de ecran și de iluminarea din spate"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Reduceţi luminozitatea şi/sau durata până la dezactivarea ecranului"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Baterie utilizată de Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="3355461362094706957">"Dezactivați rețeaua Wi-Fi atunci când nu o utilizați sau când nu este disponibilă"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Baterie utilizată de Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Dezactivaţi funcţia Bluetooth atunci când nu o utilizaţi"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Încercaţi să vă conectaţi la un alt dispozitiv Bluetooth"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Baterie utilizată de aplicaţii"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Opriţi sau dezinstalaţi aplicaţia"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Selectați modul de economisire a bateriei"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplicaţia poate oferi setări pentru reducerea utilizării bateriei"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Baterie utilizată de utilizator"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> de la deconectare"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"De la ultima deconectare pentru <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Totaluri privind utilizarea"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Actualizaţi"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Sistem de operare Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Server media"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistici de proces"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Statistici inteligente despre procesele care rulează"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Utilizarea memoriei"</string>
    <string name="process_stats_total_duration" msgid="1869761515101180444">"Aplicații de tip <xliff:g id="TYPE">%1$s</xliff:g> în <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"În fundal"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"În prim-plan"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"În cache"</string>
    <string name="process_stats_memory_status" msgid="4251599550196193093">"Memoria dispozitivului este în prezent <xliff:g id="MEMSTATE">%1$s</xliff:g>"</string>
    <string name="process_stats_avg_ram_use" msgid="6972943528929394396">"Utilizare medie RAM"</string>
    <string name="process_stats_max_ram_use" msgid="3273876448926689261">"Utilizare maximă RAM"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Durată de rulare"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Servicii"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Durată"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 ore"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 ore"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 ore"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"O zi"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Afișați sistemul"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Utilizați Uss"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Tipul de statistici"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"În fundal"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"În prim-plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"În cache"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Intrare şi ieşire voce"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Setări de intrare şi de ieşire a vocii"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Căutare vocală"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Tastatură Android"</string>
    <string name="voice_category" msgid="1430370497125803904">"Voce"</string>
    <string name="recognizer_title" msgid="3231385184559054457">"Recunoaştere voce"</string>
    <string name="recognizer_settings_title" msgid="432493301215113154">"Căutare vocală"</string>
    <string name="recognizer_settings_summary" msgid="4472287934134546902">"Setări pentru „<xliff:g id="RECOGNIZER_NAME">%s</xliff:g>”"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Setări text în vorbire"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Transformare text în vorbire"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Doresc să se utilizeze întotdeauna setările mele"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Setările prestabilite de mai jos înlocuiesc setările aplicaţiei"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Setări standard"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Motor prestabilit"</string>
    <string name="tts_default_synth_summary" msgid="6482936537135251690">"Setează utilizarea motorului de sintetizare a vorbirii pentru textul vorbit"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Ritmul vorbirii"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Viteza cu care este vorbit textul"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Înălţime"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Afectează tonul textului vorbit"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Limbă"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Nu ați selectat limba"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Setează vocea caracteristică limbii pentru textul vorbit"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Ascultaţi un exemplu"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Redaţi o demonstraţie scurtă a sintetizării vorbirii"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Instalaţi date vocale"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Instalaţi datele vocale necesare pentru sintetizarea vorbirii"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Vocile necesare pentru sintetizarea vorbirii sunt deja instalate corect"</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Setările s-au modificat. Acesta este un exemplu de sunet pentru aceste setări."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Motorul pe care l-aţi ales nu poate rula."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Configuraţi"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Alegeţi alt motor"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Acest motor de sintetizare a vorbirii poate culege în întregime textul vorbit, inclusiv datele personale cum ar fi parolele şi numerele cărţilor de credit. Metoda provine de la motorul <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Permiteţi utilizarea acestui motor de sintetizare a vorbirii?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"Pentru rezultatul transformării textului în vorbire pentru această limbă este necesară o conexiune de reţea care să funcţioneze."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"Acesta este un exemplu de sintetizare a vorbirii"</string>
    <string name="tts_status_title" msgid="7268566550242584413">"Starea limbii prestabilite"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"<xliff:g id="LOCALE">%1$s</xliff:g> este acceptată integral"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"<xliff:g id="LOCALE">%1$s</xliff:g> necesită conexiune la rețea"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"<xliff:g id="LOCALE">%1$s</xliff:g> nu este acceptată"</string>
    <string name="tts_status_checking" msgid="4983413982985913047">"Se verifică..."</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Motoare"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"Setări <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> este activat"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> este dezactivat"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Setările motorului"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Setări pentru <xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Limbi şi voci"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Instalată"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Neinstalată"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Feminină"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Masculină"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Motorul de sint. a vorb. instalat"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Activ. mot. nou înaintea util."</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Lansaţi setările motorului"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Motor preferat"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Preferinţe generale"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Comandă alimentare"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Se actualizează setarea Wi-Fi"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Se actualizează setarea pentru 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">"activat"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"dezactivat"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"se activează"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"se dezactivează"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Locație"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sincronizaţi"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Luminozitate <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automată"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"completă"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"pe jumătate"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"dezactivată"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Stocarea acreditărilor"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instalaţi de pe stocare"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instalaţi de pe cardul SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Instalaţi certificate de pe stocare"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Instalaţi certificate de pe cardul SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Ștergeţi acreditările"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Eliminaţi toate certificatele"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Acreditări de încredere"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Afişaţi certificatele CA de încredere"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Tip de stocare"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Stocare hardware"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Stocare software"</string>
    <string name="credentials_install_gesture_prompt" msgid="2207390278112395082">"Desenaţi modelul pentru deblocare"</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Trebuie să desenaţi modelul pentru deblocare pentru a confirma instalarea acreditării."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Introduceţi parola pentru spaţiul de stocare a certificatelor."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Parola actuală:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Eliminaţi întregul conţinut?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Parola trebuie să conţină minimum 8 caractere."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Parolă incorectă."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Parolă incorectă. Mai aveţi dreptul la o singură încercare înainte ca stocarea acreditărilor să fie ştearsă."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Parolă incorectă. Mai aveţi dreptul la <xliff:g id="NUMBER">%1$d</xliff:g> încercări înainte ca stocarea acreditărilor să fie ştearsă."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Stoc. acredit. este ştearsă."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Nu s-a şters sp. stoc. cert."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Stocarea acreditărilor este activată."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Trebuie să setaţi un cod PIN sau o parolă pentru blocarea ecranului înainte de a putea utiliza spaţiul de stocare a certificatelor."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Ton de urgenţă"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Setaţi comportamentul la efectuarea unui apel de urgenţă"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Backup și resetare"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Backup și resetare"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Backup și restabilire"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Date personale"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Backup pentru date"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Creați o copie de rezervă pentru datele aplicației, parolele Wi-Fi și pentru alte setări pe serverele Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Cont de backup"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"În prezent, niciun cont nu stochează datele cu copii de rezervă"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Restabilire automată"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"La reinstalarea unei aplicaţii, restabiliţi setările şi datele pentru care aţi creat o copie de rezervă"</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Parolă cop. rez. desktop"</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"În prezent, copiile de rezervă complete pe desktop nu sunt protejate"</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Atingeţi pentru a modifica sau pentru a elimina parola pentru copiile de rezervă complete pe desktop"</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"A fost setată o parolă de rezervă nouă"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Parola nouă şi confirmarea acesteia nu se potrivesc."</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Setarea parolei de rezervă a eşuat"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Doriți să opriți crearea copiei de rezervă pentru parolele Wi-Fi, marcaje, alte setări, datele aplicațiilor și să ștergeți toate copiile aflate pe serverele Google?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Setări de administrare a dispozitivului"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Administrator de dispozitive"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Dezactivaţi"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Administratori de dispozitive"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Nu există niciun administrator de dispozitive disponibil"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Activaţi administratorul de dispozitive?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Activaţi"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Administrator de dispozitive"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Activarea acestui administrator va permite aplicaţiei <xliff:g id="APP_NAME">%1$s</xliff:g> să efectueze următoarele operaţiuni:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Acest administrator este activ şi permite aplicaţiei <xliff:g id="APP_NAME">%1$s</xliff:g> să efectueze următoarele operaţii:"</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Fără titlu"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"General"</string>
    <string name="sound_category_notification_title" msgid="3502115998790286943">"Notificări"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Ton de sonerie şi vibraţii"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Sistem"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Configurare Wi-Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Conectați-vă la rețeaua Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Se conectează la rețeaua Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>…"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Conectat la rețeaua Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Adăugaţi o reţea"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Neconectat"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Adăugaţi reţea"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Actualizaţi lista"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Omiteţi"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Înainte"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Înapoi"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Detalii reţea"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Conect."</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Ștergeţi"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Salvaţi"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Anulaţi"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Se scanează reţelele..."</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Atingeţi o reţea pentru a vă conecta la aceasta"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Conectaţi-vă la reţeaua existentă"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Conectaţi-vă la o reţea nesecuriz."</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Introduceţi configuraţia reţelei"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Conectaţi-vă la o reţea nouă"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Se conectează..."</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Accesaţi pasul următor"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"EAP nu este acceptat."</string>
    <string name="wifi_setup_eap_not_supported" msgid="1955087534276570962">"Nu puteți configura o conexiune Wi-Fi EAP în timpul instalării. După instalare, puteți face acest lucru în Setări &gt; Rețele wireless."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Conectarea poate dura câteva minute..."</string>
    <string name="wifi_setup_description_connected" msgid="736032046548460779">"Atingeți "<b>"Înainte"</b>" pentru a continua configurarea.\n\nAtingeți "<b>"Înapoi"</b>" pentru a vă conecta la altă rețea Wi-Fi."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sincronizare activată"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sincronizare dezactivată"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Eroare de sincronizare."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sincronizare eşuată"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sincronizare activă"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sincronizare"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sincronizarea se confruntă în prezent cu probleme. Aceasta va fi funcţională în curând."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Adăugaţi un cont"</string>
    <string name="background_data" msgid="5779592891375473817">"Date de fundal"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplicaţiile pot oricând sincroniza, trimite şi primi date"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Dez. dat. de fundal?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Dezactivarea datelor de fundal creşte durata de viaţă a bateriei şi reduce nivelul de utilizare a datelor. Anumite aplicaţii pot utiliza în continuare conexiunea de date de fundal."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Sinc. autom. a datelor aplicaţiei"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sinc. este ACTIVATĂ"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sinc. este DEZACTIV."</string>
    <string name="sync_error" msgid="5060969083117872149">"Eroare de sincroniz."</string>
    <string name="last_synced" msgid="4242919465367022234">"Ultima sincronizare <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Se sincronizează acum…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Setări copie de rezervă"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Creaţi o copie de rezervă a setărilor dvs."</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sincronizaţi acum"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Anulaţi sincronizarea"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Atingeţi pentru a sincroniza acum<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">"Calendar"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Agendă"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Bun venit la Sincronizarea Google!"</font>" \nO abordare Google asupra sincronizării datelor, care vă permite accesul la agenda dvs., la întâlniri şi la multe alte informaţii, oriunde v-aţi afla."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Setări privind sincronizarea aplicaţiei"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Datele şi sincronizarea"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Schimbaţi parola"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Setări cont"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Eliminaţi contul"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Adăugaţi un cont"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Finalizaţi"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Eliminaţi contul?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Eliminarea acestui cont va şterge toate mesajele şi persoanele din agendă pe care le cuprinde, precum şi alte date de pe tabletă!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Eliminarea acestui cont va şterge toate mesajele şi persoanele din agendă pe care le cuprinde, precum şi alte date de pe telefon!"</string>
    <string name="remove_account_failed" product="tablet" msgid="3086620478225952725">"Acest cont este necesar pentru unele aplicaţii. Puteţi elimina contul numai prin resetarea tabletei la setările prestabilite din fabrică (acţiune care şterge toate datele personale), din Setări &gt; Creaţi copie de rezervă şi resetaţi."</string>
    <string name="remove_account_failed" product="default" msgid="6217238709175617517">"Acest cont este necesar pentru unele aplicaţii. Puteţi elimina contul numai prin resetarea telefonului la setările prestabilite din fabrică (acţiune care şterge toate datele personale), din Setări &gt; Creaţi copie de rezervă şi resetaţi."</string>
    <string name="provider_label" msgid="7724593781904508866">"Abonamente de tip push"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Sincronizarea manuală nu este posibilă"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"În prezent, sincronizarea pentru acest element este dezactivată. Pentru a schimba această setare, activaţi temporar datele de fundal şi sincronizarea automată."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Adresă MAC 4G"</string>
    <string name="enter_password" msgid="4131758584074246224">"Introduceţi parola pentru a decripta stocarea"</string>
    <string name="try_again" msgid="4272075051293936921">"Încercaţi din nou."</string>
    <string name="delete" msgid="4219243412325163003">"Ștergeţi"</string>
    <string name="misc_files" msgid="6720680815969643497">"Fişiere diverse"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"au fost selectate <xliff:g id="NUMBER">%1$d</xliff:g> din <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> din <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Selectaţi-le pe toate"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"Verificare HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Setaţi comp. verif. HDCP"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Depanare"</string>
    <string name="debug_app" msgid="8349591734751384446">"Selectaţi aplicaţia de depanare"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Nu aţi setat o aplicaţie de depanare"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Aplicaţie de depanare: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Selectaţi o aplicaţie"</string>
    <string name="no_application" msgid="2813387563129153880">"Niciuna"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Aşteptaţi depanatorul"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Înaintea executării, aplicaţia aşteaptă ataşarea depanatorului"</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Intrare"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Desen"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Redare accelerată hardware"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Monitorizare"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Modul Strict activat"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Ilum. intermit. la operaţii lungi pe firul princ."</string>
    <string name="pointer_location" msgid="6084434787496938001">"Locaţia indicatorului"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Suprap. pe ecran indic. date curente pt. atingeri"</string>
    <string name="show_touches" msgid="1356420386500834339">"Afişaţi atingerile"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Afişaţi feedback vizual pentru atingeri"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Afiş. actualiz. suprafeţe"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Iluminare suprafeţe toată fereastra la actualizare"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Afiş. actualiz. ecran GPU"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Iluminare ecrane din ferestre la desenarea cu GPU"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Actualiz. strat. hardware"</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Straturile hardware clipesc verde la actualizare"</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Depanați suprapunerea"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Dezactivaţi suprapun. HW"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Utilizaţi mereu GPU pentru compunerea ecranului"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Monitorizări OpenGL"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Afişaţi limite aspect"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Afişaţi limitele clipului, marginile etc."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Direcție aspect dr. - st."</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Direcție obligatorie aspect ecran dreapta - stânga"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Afişaţi utiliz. procesor."</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Suprap. pe ecran indic. util. curentă a procesor."</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Forţaţi redarea cu GPU"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Forţaţi utilizarea GPU pentru desen în 2D"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Forţaţi MSAA 4x"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Activaţi MSAA 4x în aplicaţiile OpenGL ES 2.0"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Remediați decupări nerectangulare"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profil redare cu GPU"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Scara anim. în fereastră"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Scară pt. anim. cu tranz."</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Scară durată Animator"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Simulaţi afişaje secundare"</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Aplicaţii"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Nu păstraţi activităţile"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Elimină activitățile imediat ce utilizatorul le închide"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Limita proces. de fundal"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Afişaţi toate elem. ANR"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Afiş. dialog. Aplic. nu răsp. pt. aplic. de fundal"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Utilizarea datelor"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Ciclul de util. a datelor"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Roaming de date"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Restricţionaţi datele de fundal"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Utilizarea 4G afişată separat"</string>
    <string name="data_usage_menu_show_wifi" msgid="5056401102877964564">"Afișați utilizarea Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Afişaţi utiliz. conex. Ethernet"</string>
    <string name="data_usage_menu_metered" msgid="5056695223222541863">"Hotspoturi mobile"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Sincronizați automat datele"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Schimbaţi data ciclului..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Ziua din lună pentru resetarea ciclului de utilizare a datelor:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Nicio aplic. nu a utilizat date în ac. perioadă."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Prim plan"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Fundal"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"limitată"</string>
    <string name="data_usage_disable_mobile" msgid="5211007048880167438">"Dezactivaţi datele mobile?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Setaţi limita pentru date mobile"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Setaţi limita de date 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Setaţi limita de date 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Setați limită date 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="454140350007299045">"Mobile"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobile"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Niciuna"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Date mobile"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Date 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Date 4G"</string>
    <string name="data_usage_app_settings" msgid="8430240158135453271">"Afişaţi setările aplicaţiei"</string>
    <string name="data_usage_app_restrict_background" msgid="9149728936265100841">"Restricţionaţi datele de fundal"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="518658001418490405">"Dezact. date de fundal în reţele mobile. Dacă sunt dispon., utiliz. reţele non-mobile."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Pt. restr. dat. fundal pt. aplic., set. întâi lim. pt. date mob."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Restricţionaţi datele de fundal?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Această funcţie poate face ca o aplicaţie care depinde de datele de fundal să nu mai funcţioneze când sunt disponibile numai reţele mobile.\n\nPuteţi găsi comenzi mai adecvate pentru utilizarea datelor în setările disponibile în cadrul aplicaţiei."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="7086969103661420799">"Restricţionarea datelor de fundal este posibilă numai dacă aţi setat o limită de date mobile."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Activaţi sinc. autom. a datelor?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="7312283529426636845">"Modificările conturilor dvs. pe web vor fi copiate automat pe tabletă.\n\nUnele conturi pot să copieze automat toate modificările de pe tabletă pe web. Așa funcționează un Cont Google.\n\nPentru a alege ce tipuri de informații se pot sincroniza în fiecare cont, accesați Setări &gt; Conturi."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="2374996799819303283">"Modificările conturilor dvs. pe web vor fi copiate în mod automat pe telefon.\n\nUnele conturi pot să copieze, de asemenea, în mod automat toate modificările pe care le efectuaţi pe telefon pe web. Aşa funcţionează un Cont Google.\n\nPentru a alege ce tipuri de informaţii se pot sincroniza în fiecare cont, accesaţi Setări &gt; Conturi."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Dezact. sinc. autom. a datelor?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"Această acţiune va economisi date şi durata bateriei, dar va trebui să sincronizaţi fiecare cont manual pentru a culege informaţiile recente. În plus, nu veţi primi notificări atunci când apar actualizări."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Data de resetare a ciclului de utilizare"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Data din fiecare lună:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Setaţi"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Setaţi un avertisment de utilizare a datelor"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Setaţi o limită de utilizare a datelor"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Limitarea utilizării datelor"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="3893348029612821262">"Conexiunea de date mobile va fi dezactivată la atingerea limitei specificate.\n\nDin moment ce utilizarea de date este măsurată de tableta dvs., iar operatorul poate contabiliza în mod diferit utilizarea, vă recomandăm să utilizaţi o limită estimativă."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="7962145861903746827">"Conexiunea de date mobile va fi dezactivată la atingerea limitei specificate.\n\nDin moment ce utilizarea de date este măsurată de telefonul dvs., iar operatorul poate contabiliza în mod diferit utilizarea, vă recomandăm să utilizaţi o limită estimativă."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Restricţionaţi datele de fundal?"</string>
    <string name="data_usage_restrict_background" msgid="8447934953579275363">"Dacă limitați transferul de date mobile în fundal, unele aplicații și servicii nu vor funcționa decât dacă sunteți conectat(ă) la o rețea Wi-Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7132639594296036143">"Dacă limitați transferul de date mobile în fundal, unele aplicații și servicii nu vor funcționa decât dacă sunteți conectat(ă) la o rețea Wi-Fi.\n\nAceastă setare afectează toți utilizatorii de pe această tabletă."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="2642864376010074543">"Dacă limitați transferul de date mobile în fundal, unele aplicații și servicii nu vor funcționa decât dacă sunteți conectat(ă) la o rețea Wi-Fi.\n\nAceastă setare afectează toți utilizatorii de pe acest telefon."</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">"avertisment"</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">"limită"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Aplicaţii eliminate"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Aplicaţii şi utilizatori eliminaţi"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"<xliff:g id="RECEIVED">%1$s</xliff:g> primiţi, <xliff:g id="SENT">%2$s</xliff:g> trimişi"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: aproximativ <xliff:g id="TOTAL">%1$s</xliff:g> utilizaţi."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="5961720793603268572">"<xliff:g id="RANGE">%2$s</xliff:g>: aprox. <xliff:g id="TOTAL">%1$s</xliff:g> utilizaţi, conform tabletei. Contabilizarea operatorului poate diferi."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="1625833170144610767">"<xliff:g id="RANGE">%2$s</xliff:g>: aprox. <xliff:g id="TOTAL">%1$s</xliff:g> utilizaţi, conform tel. Contabilizarea operatorului dvs. poate diferi."</string>
    <string name="data_usage_metered_title" msgid="6204750602856383278">"Hotspoturi mobile"</string>
    <string name="data_usage_metered_body" msgid="4959032833706695848">"Selectați rețelele Wi-Fi care sunt hotspoturi mobile. Utilizarea acestor rețele poate fi restricționată pentru aplicațiile care se află în fundal. De asemenea, aplicațiile pot emite o avertizare înainte de a utiliza aceste rețele pentru descărcări mari."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Reţele mobile"</string>
    <string name="data_usage_metered_wifi" msgid="8540872226614404873">"Rețele Wi-Fi"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="5502020778468643732">"Pentru a selecta hotspoturi mobile, activați Wi-Fi."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Apel de urgenţă"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Reveniţi la apel"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Nume"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Tip"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresă server"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Criptare PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Secret L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identificator IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Cheie IPSec predistribuită"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Certificat de utilizator IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certificat CA IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certificat de server IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Afişaţi opţiunile avansate"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domenii de căutare DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Serverele DNS (de ex., 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Rute de redirecţionare (ex.: 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Nume de utilizator"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Parolă"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Salvaţi informaţiile contului"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(neutilizat)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(nu verificaţi serverul)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(primit de la server)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Anulaţi"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Salvaţi"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Conectaţi"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Editaţi profilul VPN"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Conectaţi-vă la <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Adăugaţi un profil VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Editaţi profilul"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Ștergeţi profilul"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Reţea VPN activată permanent"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Selectaţi un profil VPN pentru a rămâne conectat întotdeauna la reţea. Traficul de reţea va fi permis numai atunci când sunteţi conectat(ă) la această reţea VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Niciuna"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Activarea permanentă a reţelei VPN necesită o adresă IP, atât pentru server, cât şi pentru DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Nu există nicio conexiune la reţea. Încercaţi din nou mai târziu."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Lipseşte un certificat. Editaţi profilul."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Utilizator"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Dezactivaţi"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Activaţi"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Eliminaţi"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Activaţi certificatul CA de sistem?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Dezactivaţi certificatul CA de sistem?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Eliminaţi definitiv certificatul de utilizator CA?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Verificator ortografic"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Introduceţi aici parola actuală pentru copia de rezervă completă"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Introduceţi aici o parolă nouă pentru copiile de rezervă complete"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Reintroduceţi aici noua parolă pentru copia de rezervă completă"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Setaţi parola pentru copia de rezervă"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Anulaţi"</string>
    <string name="percentage" msgid="5866131581207788624">"<xliff:g id="NUMBER">%d</xliff:g>%%"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Actualizări de sistem suplimentare"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Dezactivat"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Facultativ"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Obligatoriu"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Rețeaua poate fi monitorizată"</string>
    <string name="done_button" msgid="1991471253042622230">"Terminat"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="5339377665264149395">"Monitorizarea rețelei"</string>
    <string name="ssl_ca_cert_info_message" msgid="4583879256548819713">"Acest dispozitiv este administrat de:\n<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>\n\nAdministratorul poate să monitorizeze activitatea dvs. în rețea, inclusiv mesajele e-mail, aplicațiile și site-urile securizate.\n\nPentru mai multe informații, contactați administratorul."</string>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"O terță parte vă poate monitoriza activitatea în rețea, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nAcest lucru este posibil datorită unui certificat de încredere instalat pe dispozitivul dvs."</string>
    <string name="ssl_ca_cert_settings_button" msgid="8760495070836213605">"Verificați acreditările de încredere"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Utilizatori"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Utilizatori și profiluri"</string>
    <string name="user_add_user_menu" msgid="3154537325132012954">"Adăugați un utilizator/un profil"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Profil limitat"</string>
    <string name="user_need_lock_message" msgid="2596365678651842785">"Înainte de a putea crea un profil cu permisiuni limitate, va trebui să configurați blocarea ecranului pentru a vă proteja aplicațiile și datele personale."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Configurați blocarea"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Neconfigurat"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Neconfigurat – Profil cu permisiuni limitate"</string>
    <string name="user_owner" msgid="3879126011135546571">"Proprietar"</string>
    <string name="user_you" msgid="1639158809315025986">"Dvs. (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Pseudonim"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Adăugați"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Utilizatorii dețin aplicații și materiale proprii"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Puteți restricționa accesul la aplicații și la conținut din contul dvs."</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Utilizator"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Profil limitat"</string>
    <string name="user_add_user_title" msgid="3961861593718285403">"Adăugaţi un utilizator nou"</string>
    <string name="user_add_user_message_long" msgid="3086244205384741788">"Puteți să permiteți accesul la acest gadget altor persoane, prin crearea unor utilizatori suplimentari. Fiecare utilizator are propriul spațiu, pe care îl poate personaliza cu propriile sale aplicații, imagini de fundal etc. De asemenea, utilizatorii pot ajusta setările tabletei, cum ar fi setările pentru Wi-Fi, care afectează pe toți ceilalți utilizatori.\n\nDupă ce creați un utilizator nou, respectiva persoană trebuie să parcurgă un proces de configurare.\n\nOricare utilizator poate accepta permisiunile aplicațiilor actualizate în numele tuturor celorlalți utilizatori."</string>
    <string name="user_add_user_message_short" msgid="3310933423737035428">"După ce creaţi un utilizator nou, respectiva persoană trebuie să parcurgă un proces de configurare.\n\nOricare utilizator poate accepta permisiunile aplicaţiilor actualizate în numele tuturor celorlalţi utilizatori."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Configuraţi utilizatorul acum?"</string>
    <string name="user_setup_dialog_message" msgid="614037943337008555">"Asiguraţi-vă că respectiva persoană poate să preia tableta şi să îşi configureze propriul spaţiu"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Configurați profilul acum?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Configuraţi acum"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Nu acum"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="8440449301994432789">"Numai proprietarul tabletei poate gestiona utilizatorii."</string>
    <string name="user_cannot_manage_message" product="default" msgid="1133251987818014757">"Numai proprietarul telefonului poate gestiona utilizatorii."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Profilurile cu permisiuni limitate nu pot adăuga conturi"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Ștergeţi <xliff:g id="USER_NAME">%1$s</xliff:g> de pe gadget"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Utilizator nou"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Profil nou"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Vă eliminaţi ca utilizator?"</string>
    <string name="user_confirm_remove_title" msgid="3856148232937245711">"Eliminaţi utilizatorul?"</string>
    <string name="user_profile_confirm_remove_title" msgid="7399928935979459016">"Eliminați profilul?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="8167855311779740207">"Veţi pierde spaţiul şi datele de pe această tabletă. Nu puteţi anula această acţiune."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5391888073786090274">"Veţi pierde spaţiul şi datele de pe acest telefon. Nu puteţi anula această acţiune."</string>
    <string name="user_confirm_remove_message" product="tablet" msgid="4610106937214870034">"Spaţiul şi datele acestui utilizator vor dispărea de pe tabletă. Nu puteţi anula această acţiune."</string>
    <string name="user_confirm_remove_message" product="default" msgid="8130264611683731142">"Spaţiul şi datele acestui utilizator vor dispărea de pe telefon. Nu puteţi anula această acţiune."</string>
    <string name="user_profile_confirm_remove_message" product="tablet" msgid="3071489858733409187">"Spațiul și datele acestui profil vor dispărea de pe tabletă. Nu puteți anula această acțiune."</string>
    <string name="user_profile_confirm_remove_message" product="default" msgid="7078238859138335893">"Spațiul și datele acestui profil vor dispărea de pe telefon. Nu puteți anula această acțiune."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Se adaugă un utilizator nou…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Ștergeţi utilizatorul"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Ștergeţi"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Permiteți aplicații și conținut"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplicații cu restricții"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Extindeți setările aplicației"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Dezinstalați această aplicație"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Setările pentru ecranul de pornire vor fi ascunse până la instalarea altei aplicații ecran de pornire."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Această setare afectează toţi utilizatorii de pe această tabletă."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Această setare afectează toţi utilizatorii de pe acest telefon."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Schimbaţi limba"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Modificaţi dimensiunea fontului"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Atingeți și plătiți"</string>
    <string name="nfc_payment_no_apps" msgid="2481080809791416010">"Plătiți cu o atingere"</string>
    <string name="nfc_payment_learn_more" msgid="5583407773744324447">"Aflați mai multe"</string>
    <string name="nfc_payment_menu_item_add_service" msgid="2885947408068969081">"Găsiți aplicații"</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Setați ca preferință?"</string>
    <string name="nfc_payment_set_default" msgid="8961120988148253016">"Utilizați întotdeauna <xliff:g id="APP">%1$s</xliff:g> pentru funcția „atingeți și plătiți”?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="3803693771001226795">"Utilizați întotdeauna <xliff:g id="APP_0">%1$s</xliff:g> în loc de <xliff:g id="APP_1">%2$s</xliff:g> pentru funcția „atingeți și plătiți”?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Restricții"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Eliminați restricțiile"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Schimbați codul PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Afişaţi notificările"</string>
    <string name="help_label" msgid="1107174367904110532">"Ajutor"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Cont pentru conţinut"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografie"</string>
    <string name="cell_broadcast_settings" msgid="8415582011920085222">"Transmisii celulare"</string>
    <string name="user_restrictions_title" msgid="7745810037152772035">"Restricții aplicații și conținut"</string>
    <string name="user_rename" msgid="8523499513614655279">"REDENUMIȚI"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Setați restricțiile aplicației"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Controlate de <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_not_supported_in_limited" msgid="913035259626149121">"Această aplicație nu este acceptată pentru profilurile cu permisiuni limitate"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Această aplicație poate accesa conturile dvs."</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Rețele Wi‑Fi și mobile"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Permiteți modificarea setărilor pentru rețele Wi‑Fi și mobile"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Permiteți modificarea împerecherilor și setărilor Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Permiteți schimbul de date atunci când tableta atinge alt dispozitiv"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Permiteți schimbul de date atunci când telefonul atinge alt dispozitiv"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Locație"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Permiteți ca aplicațiile să utilizeze informațiile despre locație"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Înapoi"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Înainte"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Finalizați"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Faceți o fotografie"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Alegeți o fotografie din Galerie"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
</resources>
