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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="phoneAppLabel" product="tablet" msgid="1916019789885839910">"Date pentru mobil"</string>
    <string name="phoneAppLabel" product="default" msgid="130465039375347763">"Telefon – Servicii"</string>
    <string name="emergencyDialerIconLabel" msgid="8668005772339436680">"Telefon de urgență"</string>
    <string name="phoneIconLabel" msgid="3015941229249651419">"Telefon"</string>
    <string name="fdnListLabel" msgid="4119121875004244097">"Listă NAR"</string>
    <string name="unknown" msgid="8279698889921830815">"Necunoscut"</string>
    <string name="private_num" msgid="4487990167889159992">"Număr privat"</string>
    <string name="payphone" msgid="7936735771836716941">"Telefon public"</string>
    <string name="onHold" msgid="6132725550015899006">"În așteptare"</string>
    <string name="carrier_mmi_msg_title" msgid="6050165242447507034">"Mesaj <xliff:g id="MMICARRIER">%s</xliff:g>"</string>
    <string name="default_carrier_mmi_msg_title" msgid="7754317179938537213">"Mesaj de la operator"</string>
    <string name="mmiStarted" msgid="9212975136944568623">"Cod MMI pornit"</string>
    <string name="ussdRunning" msgid="1163586813106772717">"Se rulează codul USSD..."</string>
    <string name="mmiCancelled" msgid="5339191899200678272">"Cod MMI anulat"</string>
    <string name="cancel" msgid="8984206397635155197">"Anulați"</string>
    <string name="enter_input" msgid="6193628663039958990">"Mesajul USSD trebuie să aibă între <xliff:g id="MIN_LEN">%1$d</xliff:g> și <xliff:g id="MAX_LEN">%2$d</xliff:g> caractere. Încercați din nou."</string>
    <string name="manageConferenceLabel" msgid="8415044818156353233">"Gestionați teleconferința"</string>
    <string name="ok" msgid="7818974223666140165">"OK"</string>
    <string name="audio_mode_speaker" msgid="243689733219312360">"Difuzor"</string>
    <string name="audio_mode_earpiece" msgid="2823700267171134282">"Casca dispozitivului"</string>
    <string name="audio_mode_wired_headset" msgid="5028010823105817443">"Cască cu fir"</string>
    <string name="audio_mode_bluetooth" msgid="25732183428018809">"Bluetooth"</string>
    <string name="wait_prompt_str" msgid="5136209532150094910">"Trimiteți următoarele tonuri?\n"</string>
    <string name="pause_prompt_str" msgid="2308897950360272213">"Se trimit tonuri\n"</string>
    <string name="send_button" msgid="5070379600779031932">"Trimiteți"</string>
    <string name="pause_prompt_yes" msgid="8184132073048369575">"Da"</string>
    <string name="pause_prompt_no" msgid="2145264674774138579">"Nu"</string>
    <string name="wild_prompt_str" msgid="5858910969703305375">"Înlocuiți metacaracterul cu"</string>
    <string name="no_vm_number" msgid="6623853880546176930">"Lipsește numărul mesageriei vocale"</string>
    <string name="no_vm_number_msg" msgid="5165161462411372504">"Niciun număr de mesagerie vocală nu este stocat pe cardul SIM."</string>
    <string name="add_vm_number_str" msgid="7368168964435881637">"Adăugați numărul"</string>
    <string name="voice_number_setting_primary_user_only" msgid="3394706575741912843">"Setările pentru mesagerie vocală pot fi modificate numai de utilizatorul principal."</string>
    <string name="puk_unlocked" msgid="4627340655215746511">"Cardul dvs. SIM a fost deblocat. Telefonul dvs. se deblochează..."</string>
    <string name="label_ndp" msgid="7617392683877410341">"Codul PIN de deblocare a rețelei SIM"</string>
    <string name="sim_ndp_unlock_text" msgid="7737338355451978338">"Deblocați"</string>
    <string name="sim_ndp_dismiss_text" msgid="89667342248929777">"Renunțați"</string>
    <string name="requesting_unlock" msgid="930512210309437741">"Se solicită deblocarea rețelei..."</string>
    <string name="unlock_failed" msgid="7103543844840661366">"Cererea de deblocare a rețelei a eșuat."</string>
    <string name="unlock_success" msgid="32681089371067565">"Rețeaua a fost deblocată."</string>
    <string name="mobile_network_settings_not_available" msgid="8678168497517090039">"Setările pentru rețeaua mobilă nu sunt disponibile pentru acest utilizator"</string>
    <string name="labelGSMMore" msgid="7354182269461281543">"Setările apelului GSM"</string>
    <string name="labelGsmMore_with_label" msgid="3206015314393246224">"Setări pentru apeluri GSM (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="labelCDMAMore" msgid="7937441382611224632">"Setările apelului CDMA"</string>
    <string name="labelCdmaMore_with_label" msgid="7759692829160238152">"Setări pentru apeluri CDMA (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="apn_settings" msgid="1978652203074756623">"Numele punctelor de acces"</string>
    <string name="settings_label" msgid="9101778088412567956">"Setări de rețea"</string>
    <string name="phone_accounts" msgid="1216879437523774604">"Conturi pentru apelare"</string>
    <string name="phone_accounts_make_calls_with" msgid="16747814788918145">"Apelați cu"</string>
    <string name="phone_accounts_make_sip_calls_with" msgid="4691221006731847255">"Dați apeluri SIP cu"</string>
    <string name="phone_accounts_ask_every_time" msgid="6192347582666047168">"Întreabă mai întâi"</string>
    <string name="phone_accounts_default_account_label" msgid="5107598881335931101">"Nicio rețea disponibilă"</string>
    <string name="phone_accounts_settings_header" msgid="6296501692964706536">"Setări"</string>
    <string name="phone_accounts_choose_accounts" msgid="4748805293314824974">"Alegeți conturile"</string>
    <string name="phone_accounts_selection_header" msgid="2945830843104108440">"Conturi telefon"</string>
    <string name="phone_accounts_add_sip_account" msgid="1437634802033309305">"Adăugați un cont SIP"</string>
    <string name="phone_accounts_configure_account_settings" msgid="6622119715253196586">"Configurați setările contului"</string>
    <string name="phone_accounts_all_calling_accounts" msgid="1609600743500618823">"Toate conturile pentru apelare"</string>
    <string name="phone_accounts_all_calling_accounts_summary" msgid="2214134955430107240">"Selectați conturile care pot da apeluri"</string>
    <string name="wifi_calling" msgid="3650509202851355742">"Apelare prin Wi-Fi"</string>
    <string name="connection_service_default_label" msgid="7332739049855715584">"Serviciu de conectare încorporat"</string>
    <string name="voicemail" msgid="7697769412804195032">"Mesagerie vocală"</string>
    <string name="voicemail_settings_with_label" msgid="4228431668214894138">"Mesagerie vocală (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="voicemail_abbreviated" msgid="7746778673131551185">"MV:"</string>
    <string name="make_and_receive_calls" msgid="4868913166494621109">"Inițiați și primiți apeluri"</string>
    <string name="smart_forwarding_settings_menu" msgid="8850429887958938540">"Redirecționare intuitivă"</string>
    <string name="smart_forwarding_settings_menu_summary" msgid="5096947726032885325">"Când un număr nu este disponibil, redirecționați mereu apelurile către celălalt număr pe care îl aveți."</string>
    <string name="voicemail_notifications_preference_title" msgid="7829238858063382977">"Notificări"</string>
    <string name="cell_broadcast_settings" msgid="8135324242541809924">"Transmisiuni de urgență"</string>
    <string name="call_settings" msgid="3677282690157603818">"Setări pentru apeluri"</string>
    <string name="additional_gsm_call_settings" msgid="1561980168685658846">"Setări suplimentare"</string>
    <string name="additional_gsm_call_settings_with_label" msgid="7973920539979524908">"Setări suplimentare (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="sum_gsm_call_settings" msgid="7964692601608878138">"Setări suplimentare doar pentru apelurile GSM"</string>
    <string name="additional_cdma_call_settings" msgid="2178016561980611304">"Setări suplimentare pentru apelurile CDMA"</string>
    <string name="sum_cdma_call_settings" msgid="3185825305136993636">"Setări suplimentare numai pentru apelurile CDMA"</string>
    <string name="labelNwService" msgid="6015891883487125120">"Setările serviciului de rețea"</string>
    <string name="labelCallerId" msgid="2090540744550903172">"ID-ul apelantului"</string>
    <string name="sum_loading_settings" msgid="434063780286688775">"Se încarcă setările…"</string>
    <string name="sum_hide_caller_id" msgid="131100328602371933">"Număr ascuns în apelurile de ieșire"</string>
    <string name="sum_show_caller_id" msgid="3571854755324664591">"Numărul afișat în apelurile de ieșire"</string>
    <string name="sum_default_caller_id" msgid="1767070797135682959">"Utilizați setările prestabilite ale operatorului pentru a vă afișa numărul în apelurile efectuate"</string>
    <string name="labelCW" msgid="8449327023861428622">"Apel în așteptare"</string>
    <string name="sum_cw_enabled" msgid="3977308526187139996">"Anunță-mă dacă primesc un apel în timpul unei convorbiri"</string>
    <string name="sum_cw_disabled" msgid="3658094589461768637">"Anunță-mă dacă primesc un apel în timpul unei convorbiri"</string>
    <string name="call_forwarding_settings" msgid="8937130467468257671">"Setări de redirecționare"</string>
    <string name="call_forwarding_settings_with_label" msgid="2345432813399564272">"Setări de redirecționare (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="labelCF" msgid="3578719437928476078">"Redirecționarea apelurilor"</string>
    <string name="labelCFU" msgid="8870170873036279706">"Redirecționează întotdeauna"</string>
    <string name="messageCFU" msgid="1361806450979589744">"Folosește mereu acest număr"</string>
    <string name="sum_cfu_enabled_indicator" msgid="9030139213402432776">"Se redirecționează toate apelurile"</string>
    <string name="sum_cfu_enabled" msgid="5806923046528144526">"Se redirecționează toate apelurile către <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfu_enabled_no_number" msgid="7287752761743377930">"Numărul nu este disponibil"</string>
    <string name="sum_cfu_disabled" msgid="5010617134210809853">"Dezactivat"</string>
    <string name="labelCFB" msgid="615265213360512768">"Când este ocupat"</string>
    <string name="messageCFB" msgid="1958017270393563388">"Număr pentru redirecționare dacă este ocupat"</string>
    <string name="sum_cfb_enabled" msgid="332037613072049492">"Se redirecționează la <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfb_disabled" msgid="3589913334164866035">"Dezactivat"</string>
    <string name="disable_cfb_forbidden" msgid="4831494744351633961">"Operatorul dvs. nu acceptă ca redirecționarea apelurilor să fie dezactivată atunci când telefonul dvs. este ocupat."</string>
    <string name="labelCFNRy" msgid="3403533792248457946">"Când nu se răspunde"</string>
    <string name="messageCFNRy" msgid="7644434155765359009">"Număr pentru redirecționare dacă nu se răspunde"</string>
    <string name="sum_cfnry_enabled" msgid="3000500837493854799">"Se redirecționează la <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfnry_disabled" msgid="1990563512406017880">"Dezactivat"</string>
    <string name="disable_cfnry_forbidden" msgid="3174731413216550689">"Operatorul dvs. nu acceptă ca redirecționarea apelurilor să fie dezactivată atunci când telefonul dvs. nu răspunde."</string>
    <string name="labelCFNRc" msgid="4163399350778066013">"Când nu este accesibil"</string>
    <string name="messageCFNRc" msgid="6980340731313007250">"Număr de redirecționare dacă telefonul nu este accesibil"</string>
    <string name="sum_cfnrc_enabled" msgid="1799069234006073477">"Se redirecționează la <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfnrc_disabled" msgid="739289696796917683">"Dezactivat"</string>
    <string name="disable_cfnrc_forbidden" msgid="775348748084726890">"Operatorul dvs. nu acceptă ca redirecționarea apelurilor să fie dezactivată atunci când telefonul nu este accesibil."</string>
    <string name="updating_title" msgid="6130548922615719689">"Setări pentru apeluri"</string>
    <string name="call_settings_admin_user_only" msgid="7238947387649986286">"Numai administratorul poate să modifice setările pentru apeluri."</string>
    <string name="call_settings_with_label" msgid="8460230435361579511">"Setări (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="error_updating_title" msgid="2024290892676808965">"Eroare în setările pentru apeluri"</string>
    <string name="reading_settings" msgid="1605904432450871183">"Se citesc setările..."</string>
    <string name="updating_settings" msgid="3650396734816028808">"Se actualizează setările..."</string>
    <string name="reverting_settings" msgid="7378668837291012205">"Se revine la setări..."</string>
    <string name="response_error" msgid="3904481964024543330">"Răspuns neașteptat de la rețea."</string>
    <string name="exception_error" msgid="330994460090467">"Eroare de rețea sau de card SIM."</string>
    <string name="stk_cc_ss_to_dial_error" msgid="5147693491690618704">"Solicitarea SS a fost schimbată cu un apel obișnuit"</string>
    <string name="stk_cc_ss_to_ussd_error" msgid="8330749347425752192">"Solicitarea SS a fost schimbată cu o solicitare USSD"</string>
    <string name="stk_cc_ss_to_ss_error" msgid="8297155544652134278">"Schimbat cu o solicitare SS nouă"</string>
    <string name="stk_cc_ss_to_dial_video_error" msgid="4255261231466032505">"Solicitarea SS a fost schimbată cu un apel video"</string>
    <string name="fdn_check_failure" msgid="1833769746374185247">"Setarea Numere cu apelări restricționate din aplicația Telefon este activată. Ca rezultat, unele funcții legate de apelare nu pot fi utilizate."</string>
    <string name="radio_off_error" msgid="8321564164914232181">"Activați semnalul radio, înainte de a vizualiza aceste setări."</string>
    <string name="close_dialog" msgid="1074977476136119408">"OK"</string>
    <string name="enable" msgid="2636552299455477603">"Activați"</string>
    <string name="disable" msgid="1122698860799462116">"Dezactivați"</string>
    <string name="change_num" msgid="6982164494063109334">"Actualizați"</string>
  <string-array name="clir_display_values">
    <item msgid="8477364191403806960">"Rețea prestabilită"</item>
    <item msgid="6813323051965618926">"Ascundeți numărul"</item>
    <item msgid="9150034130629852635">"Afișați numărul"</item>
  </string-array>
    <string name="vm_changed" msgid="4739599044379692505">"Număr mesagerie vocală modificat."</string>
    <string name="vm_change_failed" msgid="7877733929455763566">"Nu s-a putut schimba numărul de mesagerie vocală.\nContactați operatorul în cazul în care această problemă persistă."</string>
    <string name="fw_change_failed" msgid="9179241823460192148">"Nu s-a putut schimba numărul de redirecționare.\nContactați operatorul dvs. în cazul în care această problemă persistă."</string>
    <string name="fw_get_in_vm_failed" msgid="2432678237218183844">"Nu s-au putut prelua și salva setările actuale ale numărului de redirecționare.\nDoriți să comutați oricum către un nou furnizor de servicii?"</string>
    <string name="no_change" msgid="3737264882821031892">"Nicio schimbare efectuată."</string>
    <string name="sum_voicemail_choose_provider" msgid="6750824719081403773">"Alegeți serviciul de mesagerie vocală"</string>
    <string name="voicemail_default" msgid="6427575113775462077">"Operatorul dvs."</string>
    <string name="vm_change_pin_old_pin" msgid="7154951790929009241">"Codul PIN vechi"</string>
    <string name="vm_change_pin_new_pin" msgid="2656200418481288069">"Codul PIN nou"</string>
    <string name="vm_change_pin_progress_message" msgid="626015184502739044">"Așteptați."</string>
    <string name="vm_change_pin_error_too_short" msgid="1789139338449945483">"Codul PIN nou este prea scurt."</string>
    <string name="vm_change_pin_error_too_long" msgid="3634907034310018954">"Codul PIN nou este prea lung."</string>
    <string name="vm_change_pin_error_too_weak" msgid="8581892952627885719">"Codul PIN nou este prea slab. O parolă puternică nu ar trebui să aibă o secvență continuă sau cifre repetitive."</string>
    <string name="vm_change_pin_error_mismatch" msgid="5364847280026257331">"Codul PIN vechi nu corespunde."</string>
    <string name="vm_change_pin_error_invalid" msgid="5230002671175580674">"Codul PIN nou conține caractere nevalide."</string>
    <string name="vm_change_pin_error_system_error" msgid="9116483527909681791">"Nu se poate schimba codul PIN"</string>
    <string name="vvm_unsupported_message_format" msgid="4206402558577739713">"Tip de mesaj neacceptat. Apelează numărul <xliff:g id="NUMBER">%s</xliff:g> pentru a-l asculta."</string>
    <string name="network_settings_title" msgid="7560807107123171541">"Rețea mobilă"</string>
    <string name="label_available" msgid="1316084116670821258">"Rețele disponibile"</string>
    <string name="load_networks_progress" msgid="4051433047717401683">"Se caută…"</string>
    <string name="empty_networks_list" msgid="9216418268008582342">"Nicio rețea găsită."</string>
    <string name="network_query_error" msgid="3862515805115145124">"Nu s-au găsit rețele. Încercați din nou."</string>
    <string name="register_on_network" msgid="4194770527833960423">"Se înregistrează pe <xliff:g id="NETWORK">%s</xliff:g>..."</string>
    <string name="not_allowed" msgid="8541221928746104798">"Cardul dvs. SIM nu permite conexiunea la această rețea."</string>
    <string name="connect_later" msgid="1950138106010005425">"Nu se poate efectua conectarea la această rețea chiar acum. Încercați din nou mai târziu."</string>
    <string name="registration_done" msgid="5337407023566953292">"Înregistrat în rețea."</string>
    <string name="already_auto" msgid="8607068290733079336">"Deja în selecție automată."</string>
    <string name="select_automatically" msgid="779750291257872651">"Selectați automat rețeaua"</string>
    <string name="manual_mode_disallowed_summary" msgid="3970048592179890197">"Indisponibil când este conectat la %1$s"</string>
    <string name="network_select_title" msgid="4117305053881611988">"Rețea"</string>
    <string name="register_automatically" msgid="3907580547590554834">"Înregistrare automată..."</string>
    <string name="preferred_network_mode_title" msgid="5253395265169539830">"Tipul de rețea preferat"</string>
    <string name="preferred_network_mode_summary" msgid="3787989000044330064">"Schimbați modul de operare a rețelei"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="2781447433514459696">"Tipul de rețea preferat"</string>
    <string name="forbidden_network" msgid="5081729819561333023">"(interzis)"</string>
    <string name="choose_network_title" msgid="5335832663422653082">"Alegeți o rețea"</string>
    <string name="network_disconnected" msgid="8844141106841160825">"Deconectat"</string>
    <string name="network_connected" msgid="2760235679963580224">"Conectat"</string>
    <string name="network_connecting" msgid="160901383582774987">"Se conectează…"</string>
    <string name="network_could_not_connect" msgid="6547460848093727998">"Nu s-a putut conecta"</string>
  <string-array name="preferred_network_mode_choices">
    <item msgid="4531933377509551889">"GSM/WCDMA preferată"</item>
    <item msgid="5120532750027435355">"Numai GSM"</item>
    <item msgid="8973311380798000102">"Numai WCDMA"</item>
    <item msgid="4139961027147085705">"GSM/WCDMA automat"</item>
    <item msgid="4024581977690585814">"CDMA/EvDo automat"</item>
    <item msgid="7199560024080522581">"CDMA fără EvDo"</item>
    <item msgid="3160291725308400608">"Numai EvDo"</item>
    <item msgid="2319217472852426965">"CDMA/EvDo/GSM/WCDMA"</item>
    <item msgid="7342827148550261533">"CDMA + LTE/EvDo"</item>
    <item msgid="1694517610683571748">"GSM/WCDMA/LTE"</item>
    <item msgid="2431844716050955858">"Global"</item>
    <item msgid="8522859526931346931">"LTE"</item>
    <item msgid="7852977970279215000">"LTE/WCDMA"</item>
    <item msgid="5779210256161024981">"Numai TDSCDMA"</item>
    <item msgid="611913646308951205">"TDSCDMA/WCDMA"</item>
    <item msgid="1738977207573340604">"LTE/TDSCDMA"</item>
    <item msgid="8506090627128783948">"TDSCDMA/GSM"</item>
    <item msgid="8818474033583337353">"LTE/TDSCDMA/GSM"</item>
    <item msgid="3102297933672336483">"TDSCDMA/GSM/WCDMA"</item>
    <item msgid="3802189736321382954">"LTE/TDSCDMA/WCDMA"</item>
    <item msgid="6147699530135006312">"LTE/TDSCDMA/GSM/WCDMA"</item>
    <item msgid="8826479449402151312">"TDSCDMA/CDMA/EVDO/GSM/WCDMA"</item>
    <item msgid="6284311629324843506">"LTE/TDSCDMA/CDMA/EVDO/GSM/WCDMA"</item>
    <item msgid="4738087170533378966">"Numai NR"</item>
    <item msgid="2935877729588775187">"NR/LTE"</item>
    <item msgid="8967513231424970529">"NR/LTE/CDMA/EvDo"</item>
    <item msgid="1542643426479755015">"NR/LTE/GSM/WCDMA"</item>
    <item msgid="5778162260258129841">"NR/LTE/CDMA/EvDo/GSM/WCDMA"</item>
    <item msgid="8088614845214545367">"NR/LTE/WCDMA"</item>
    <item msgid="6517428040626326776">"NR/LTE/TDSCDMA"</item>
    <item msgid="5294150161567170165">"NR/LTE/TDSCDMA/GSM"</item>
    <item msgid="4130965694947056705">"NR/LTE/TDSCDMA/WCDMA"</item>
    <item msgid="3869566732842046032">"NR/LTE/TDSCDMA/GSM/WCDMA"</item>
    <item msgid="3942770927563146543">"NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</item>
  </string-array>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="7851493369130750126">"Mod de rețea preferat: de preferat WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="4323367929994392830">"Mod de rețea preferat: numai GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="3585482191951442207">"Mod de rețea preferat: numai WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="2988950751948316810">"Mod de rețea preferat: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="9127141320343936911">"Mod de rețea preferat: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="3629440709757307077">"Mod de rețea preferat: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="211164451887102568">"Mod de rețea preferat: numai CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="939116631952132878">"Mod de rețea preferat: numai EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="7891131456022601976">"Mod de rețea preferat: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="8050539466545797149">"Mod de rețea preferat: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="2217794334331254936">"Mod de rețea preferat: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="5559198623419981805">"Mod de rețea preferat: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="6707224437925495615">"Mod de rețea preferat: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="3847086258439582411">"Mod de rețea preferat: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7001804022020813865">"Mod de rețea preferat: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="6484203890156282179">"Mod de rețea preferat: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="8187929456614068518">"Mod de rețea preferat: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="3602127224234207206">"Mod de rețea preferat: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="7076968749402201123">"Mod de rețea preferat: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3001058390866953624">"Mod de rețea preferat: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="1716983444872465309">"Mod de rețea preferat: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="1349057007230669585">"Mod de rețea preferat: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2092262901885164194">"Mod de rețea preferat: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="56422129430744466">"Mod de rețea preferat: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="2993923113350341106">"Mod de rețea preferat: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="2779089629254220257">"Mod de rețea preferat: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="9065672185435798587">"Mod de rețea preferat: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="1467452233297987391">"Mod de rețea preferat: numai NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="5890170406507535976">"Mod de rețea preferat: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="5507940227264296616">"Mod de rețea preferat: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="2811179121638665248">"Mod de rețea preferat: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7631365223836621902">"Mod de rețea preferat: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="8696016062943591864">"Mod de rețea preferat: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="1236182344680726751">"Mod de rețea preferat: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8384454155773415993">"Mod de rețea preferat: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="5912457779733343522">"Mod de rețea preferat: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="6769797110309412576">"Mod de rețea preferat: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="4260661428277578573">"Mod de rețea preferat: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="call_category" msgid="4394703838833058138">"Se apelează"</string>
    <string name="network_operator_category" msgid="4992217193732304680">"Rețea"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="4213420368777080540">"Mod 4G LTE îmbunătățit"</string>
    <!-- no translation found for enhanced_4g_lte_mode_title_variant:0 (7240155150166394308) -->
    <string name="enhanced_4g_lte_mode_summary" msgid="7725708511804143638">"Folosiți servicii LTE pt. a îmbunătăți comunicări vocale și altele (recomandat)"</string>
    <string name="enhanced_4g_lte_mode_summary_o2" msgid="2521108446409016542">"Folosiți servicii 4G pentru a îmbunătăți comunicările vocale și altele (recomandat)"</string>
    <!-- no translation found for enhanced_4g_lte_mode_sumary_variant:0 (2943982616649705147) -->
    <!-- no translation found for enhanced_4g_lte_mode_sumary_variant:1 (5262249464504131443) -->
    <!-- no translation found for enhanced_4g_lte_mode_sumary_variant:2 (6356974241850241718) -->
    <string name="data_enabled" msgid="22525832097434368">"Date activate"</string>
    <string name="data_enable_summary" msgid="696860063456536557">"Permiteți utilizarea datelor"</string>
    <string name="dialog_alert_title" msgid="5260471806940268478">"Atenție"</string>
    <string name="roaming" msgid="1576180772877858949">"Roaming"</string>
    <string name="roaming_enable" msgid="6853685214521494819">"Conectați-vă la serviciile de date în roaming"</string>
    <string name="roaming_disable" msgid="8856224638624592681">"Conectați-vă la serviciile de date în roaming"</string>
    <string name="roaming_reenable_message" msgid="1951802463885727915">"Roamingul de date este dezactivat. Atingeți pentru a-l activa."</string>
    <string name="roaming_enabled_message" msgid="9022249120750897">"Se pot aplica tarife de roaming. Atingeți pentru a modifica."</string>
    <string name="roaming_notification_title" msgid="3590348480688047320">"S-a pierdut conexiunea de date mobile"</string>
    <string name="roaming_on_notification_title" msgid="7451473196411559173">"Roamingul de date este activat"</string>
    <string name="roaming_warning" msgid="7855681468067171971">"Se pot acumula costuri mari."</string>
    <string name="roaming_check_price_warning" msgid="8212484083990570215">"Consultați furnizorul de rețea în privința prețurilor."</string>
    <string name="roaming_alert_title" msgid="5689615818220960940">"Permiteți roamingul de date?"</string>
    <string name="limited_sim_function_notification_title" msgid="612715399099846281">"Funcționalitate SIM limitată"</string>
    <string name="limited_sim_function_with_phone_num_notification_message" msgid="5928988883403677610">"Este posibil ca apelurile și serviciile de date de la <xliff:g id="CARRIER_NAME">%1$s</xliff:g> să fie blocate în timp ce se folosește <xliff:g id="PHONE_NUMBER">%2$s</xliff:g>."</string>
    <string name="limited_sim_function_notification_message" msgid="5338638075496721160">"Apelurile și serviciile de date de la <xliff:g id="CARRIER_NAME">%1$s</xliff:g> pot fi blocate când folosiți alt card SIM"</string>
    <string name="data_usage_title" msgid="8438592133893837464">"Date utilizate de aplicație"</string>
    <string name="data_usage_template" msgid="6287906680674061783">"<xliff:g id="ID_1">%1$s</xliff:g> de date mobile utilizate în intervalul <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="advanced_options_title" msgid="9208195294513520934">"Avansate"</string>
    <string name="carrier_settings_euicc" msgid="1190237227261337749">"Operator"</string>
    <string name="keywords_carrier_settings_euicc" msgid="8540160967922063745">"operator, esim, sim, euicc, schimbare operatori, adăugare operator"</string>
    <string name="carrier_settings_euicc_summary" msgid="2027941166597330117">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> — <xliff:g id="PHONE_NUMBER">%2$s</xliff:g>"</string>
    <string name="mobile_data_settings_title" msgid="7228249980933944101">"Date mobile"</string>
    <string name="mobile_data_settings_summary" msgid="5012570152029118471">"Accesați datele folosind rețeaua mobilă"</string>
    <string name="data_usage_disable_mobile" msgid="5669109209055988308">"Dezactivați datele mobile?"</string>
    <string name="sim_selection_required_pref" msgid="6985901872978341314">"Selectați o opțiune"</string>
    <string name="sim_change_data_title" msgid="9142726786345906606">"Schimbați cartela SIM de date?"</string>
    <string name="sim_change_data_message" msgid="3567358694255933280">"Folosiți <xliff:g id="NEW_SIM">%1$s</xliff:g> în loc de <xliff:g id="OLD_SIM">%2$s</xliff:g> pentru datele mobile?"</string>
    <string name="wifi_calling_settings_title" msgid="5800018845662016507">"Apelare prin Wi-Fi"</string>
    <string name="video_calling_settings_title" msgid="342829454913266078">"Apelare video prin operator"</string>
    <string name="gsm_umts_options" msgid="4968446771519376808">"Opțiuni GSM/UMTS"</string>
    <string name="cdma_options" msgid="3669592472226145665">"Opțiuni CDMA"</string>
    <string name="throttle_data_usage" msgid="1944145350660420711">"Utilizarea datelor"</string>
    <string name="throttle_current_usage" msgid="7483859109708658613">"Datele utilizate în perioada curentă"</string>
    <string name="throttle_time_frame" msgid="1813452485948918791">"Perioada de utilizare a datelor"</string>
    <string name="throttle_rate" msgid="7641913901133634905">"Politica ratei de transfer a datelor"</string>
    <string name="throttle_help" msgid="2624535757028809735">"Aflați mai multe"</string>
    <string name="throttle_status_subtext" msgid="1110276415078236687">"<xliff:g id="USED_0">%1$s</xliff:g> (<xliff:g id="USED_1">%2$d</xliff:g>٪) din <xliff:g id="USED_2">%3$s</xliff:g> perioada maximă\nUrmătoarea perioadă începe în <xliff:g id="USED_3">%4$d</xliff:g> zile (<xliff:g id="USED_4">%5$s</xliff:g>)"</string>
    <string name="throttle_data_usage_subtext" msgid="3185429653996709840">"<xliff:g id="USED_0">%1$s</xliff:g> (<xliff:g id="USED_1">%2$d</xliff:g>٪) din <xliff:g id="USED_2">%3$s</xliff:g> perioadă maximă"</string>
    <string name="throttle_data_rate_reduced_subtext" msgid="8369839346277847725">"<xliff:g id="USED_0">%1$s</xliff:g> maximum depășit\nRata de transfer se reduce la <xliff:g id="USED_1">%2$d</xliff:g> Kb/s"</string>
    <string name="throttle_time_frame_subtext" msgid="6462089615392402127">"<xliff:g id="USED_0">%1$d</xliff:g>٪ din ciclul trecut\nPerioada următoare începe în <xliff:g id="USED_1">%2$d</xliff:g> zile (<xliff:g id="USED_2">%3$s</xliff:g>)"</string>
    <string name="throttle_rate_subtext" msgid="7221971817325779535">"Rata de transfer a datelor se reduce la <xliff:g id="USED">%1$d</xliff:g> Kb/s, dacă limita de utilizare este depășită."</string>
    <string name="throttle_help_subtext" msgid="2817114897095534807">"Mai multe informații despre politica de utilizare a datelor aplicată de operatorul dvs. de telefonie mobilă"</string>
    <string name="cell_broadcast_sms" msgid="4053449797289031063">"Transmisie celulară a mesajelor SMS"</string>
    <string name="enable_disable_cell_bc_sms" msgid="4759958924031721350">"Transmisie celulară a mesajelor SMS"</string>
    <string name="cell_bc_sms_enable" msgid="2019708772024632073">"Transmisie celulară a mesajelor SMS activată"</string>
    <string name="cell_bc_sms_disable" msgid="1214238639910875347">"Transmisie celulară a mesajelor SMS dezactivată"</string>
    <string name="cb_sms_settings" msgid="6858093721831312036">"Setările transmisiei celulare a mesajelor SMS"</string>
    <string name="enable_disable_emergency_broadcast" msgid="6325655044472196496">"Transmisie de urgență"</string>
    <string name="emergency_broadcast_enable" msgid="5759610647771102442">"Transmisie de urgență activată"</string>
    <string name="emergency_broadcast_disable" msgid="2844904734469323266">"Transmisie de urgență dezactivată"</string>
    <string name="enable_disable_administrative" msgid="7825925366822117961">"Administrativ"</string>
    <string name="administrative_enable" msgid="5717963431079532028">"Administrativ activată"</string>
    <string name="administrative_disable" msgid="156796633660118691">"Administrativ dezactivat"</string>
    <string name="enable_disable_maintenance" msgid="3824817751053035017">"Întreținere"</string>
    <string name="maintenance_enable" msgid="2646784483222342290">"Întreținere activată"</string>
    <string name="maintenance_disable" msgid="2121032601497725602">"Întreținere dezactivată"</string>
    <string name="general_news_settings" msgid="2670499575962080411">"Știri generale"</string>
    <string name="bf_news_settings" msgid="8571709425370794221">"Știri despre afaceri și financiare"</string>
    <string name="sports_news_settings" msgid="2684364556989168438">"Știri din sport"</string>
    <string name="entertainment_news_settings" msgid="4228527702346305543">"Știri de divertisment"</string>
    <string name="enable_disable_local" msgid="7654175079979415572">"Local"</string>
    <string name="local_enable" msgid="790606890868710629">"Știri locale activate"</string>
    <string name="local_disable" msgid="7649945293198602877">"Știri locale dezactivate"</string>
    <string name="enable_disable_regional" msgid="5783403191376564638">"Regional"</string>
    <string name="regional_enable" msgid="7730109417536296079">"Știri locale activate"</string>
    <string name="regional_disable" msgid="3781951818157772545">"Știri regionale dezactivate"</string>
    <string name="enable_disable_national" msgid="6198481711934897632">"Național"</string>
    <string name="national_enable" msgid="5159683504138239304">"Știri naționale activate"</string>
    <string name="national_disable" msgid="8484356368757118987">"Știri naționale dezactivate"</string>
    <string name="enable_disable_international" msgid="4204334217211198792">"Internațional"</string>
    <string name="international_enable" msgid="8943466745792690340">"Știri internaționale activate"</string>
    <string name="international_disable" msgid="4803498658100318265">"Știri internaționale dezactivate"</string>
    <string name="list_language_title" msgid="1850167908665485738">"Limbă"</string>
    <string name="list_language_summary" msgid="7921756070782277559">"Selectați limba pentru știri"</string>
  <string-array name="list_language_entries">
    <item msgid="2347238508726934281">"Engleză"</item>
    <item msgid="5172468397620875174">"Franceză"</item>
    <item msgid="3978110664146015398">"Spaniolă"</item>
    <item msgid="2637764545851526369">"Japoneză"</item>
    <item msgid="6103816221834932751">"Coreeană"</item>
    <item msgid="3127367370005168399">"Chineză"</item>
    <item msgid="9130651361816196355">"Ebraică"</item>
  </string-array>
  <string-array name="list_language_values">
    <item msgid="798673247233934667">"1"</item>
    <item msgid="8094157729915031372">"2"</item>
    <item msgid="8800963137163545850">"3"</item>
    <item msgid="2720764514329880993">"4"</item>
    <item msgid="6180039611613399029">"5"</item>
    <item msgid="3611885482576618687">"6"</item>
    <item msgid="6685082338652847671">"7"</item>
  </string-array>
    <string name="list_language_dtitle" msgid="7457017255633587047">"Limbi"</string>
    <string name="enable_disable_local_weather" msgid="7734933941872511543">"Previziuni meteo locale"</string>
    <string name="local_weather_enable" msgid="2143929735295254729">"Previziuni meteo locale activate"</string>
    <string name="local_weather_disable" msgid="4209936355998349647">"Previziuni meteo locale dezactivate"</string>
    <string name="enable_disable_atr" msgid="821714821057385390">"Informații locale de trafic"</string>
    <string name="atr_enable" msgid="1799097759998768186">"Informații locale de trafic activate"</string>
    <string name="atr_disable" msgid="6456758173289065766">"Informații locale de trafic dezactivate"</string>
    <string name="enable_disable_lafs" msgid="7448060358300805661">"Orarele de zbor ale aeroportului local"</string>
    <string name="lafs_enable" msgid="3125783406052655690">"Orarele de zbor ale aeroportului local sunt activate"</string>
    <string name="lafs_disable" msgid="7326815066813851447">"Orarele de zbor ale aeroportului local sunt dezactivate"</string>
    <string name="enable_disable_restaurants" msgid="3873247081569423019">"Restaurante"</string>
    <string name="restaurants_enable" msgid="5810452674239139572">"Restaurante activate"</string>
    <string name="restaurants_disable" msgid="2733507854548413505">"Restaurante dezactivate"</string>
    <string name="enable_disable_lodgings" msgid="7849168585821435109">"Cazare"</string>
    <string name="lodgings_enable" msgid="2020598411398609514">"Cazare activată"</string>
    <string name="lodgings_disable" msgid="5145649659459722661">"Cazare dezactivată"</string>
    <string name="enable_disable_retail_directory" msgid="9095153426757081972">"Registrul comercianților"</string>
    <string name="retail_directory_enable" msgid="2532176568755452171">"Registrul comercianților activat"</string>
    <string name="retail_directory_disable" msgid="7242451210736299193">"Registrul comercianților dezactivat"</string>
    <string name="enable_disable_advertisements" msgid="8704125663718797151">"Publicitate"</string>
    <string name="advertisements_enable" msgid="8651409664217899145">"Publicitate activată"</string>
    <string name="advertisements_disable" msgid="2999957360508271492">"Publicitate dezactivată"</string>
    <string name="enable_disable_stock_quotes" msgid="631498357725951825">"Cotații bursiere"</string>
    <string name="stock_quotes_enable" msgid="5104318195579771947">"Cotații bursiere activate"</string>
    <string name="stock_quotes_disable" msgid="3126423481704498278">"Cotații bursiere dezactivate"</string>
    <string name="enable_disable_eo" msgid="5730223317238970819">"Oportunități de angajare"</string>
    <string name="eo_enable" msgid="107713355461019817">"Oportunități de angajare activate"</string>
    <string name="eo_disable" msgid="3955421278929647485">"Oportunități de angajare dezactivate"</string>
    <string name="enable_disable_mhh" msgid="715930476289202466">"Medicină, sănătate și spitale"</string>
    <string name="mhh_enable" msgid="7224396815285147008">"Medicină, sănătate și spitale activate"</string>
    <string name="mhh_disable" msgid="5503643028885686265">"Medicină, sănătate și spitale dezactivate"</string>
    <string name="enable_disable_technology_news" msgid="2794845609698078400">"Știri din tehnologie"</string>
    <string name="technology_news_enable" msgid="1908991199492598311">"Știri din tehnologie activate"</string>
    <string name="technology_news_disable" msgid="8388582607149800889">"Știri din tehnologie dezactivate"</string>
    <string name="enable_disable_multi_category" msgid="5958248155437940625">"Categorii multiple"</string>
    <string name="multi_category_enable" msgid="4531915767817483960">"Categorii multiple activate"</string>
    <string name="multi_category_disable" msgid="6325934413701238104">"Categorii multiple dezactivate"</string>
    <string name="network_recommended" msgid="3444321100580250926">" (recomandat)"</string>
    <string name="network_lte" msgid="7206879277095094280">"LTE (recomandat)"</string>
    <string name="network_4G" msgid="6800527815504223913">"4G (recomandat)"</string>
    <string name="network_global" msgid="3289646154407617631">"Global"</string>
    <string name="cdma_system_select_title" msgid="614165233552656431">"Selectați sistemul"</string>
    <string name="cdma_system_select_summary" msgid="3840420390242060407">"Schimbați modul de roaming CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="5524639510676501802">"Selectați sistemul"</string>
  <string-array name="cdma_system_select_choices">
    <item msgid="462340042928284921">"Doar domiciliu"</item>
    <item msgid="6058010046783562674">"Automat"</item>
  </string-array>
    <string name="cdma_subscription_title" msgid="3449527179325589434">"Abonament CMDA"</string>
    <string name="cdma_subscription_summary" msgid="5681152534466169001">"Comutați între RUIM/SIM și NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="8872086335839723980">"abonament"</string>
  <string-array name="cdma_subscription_choices">
    <item msgid="7989486897370727698">"RUIM/SIM"</item>
    <item msgid="5445342771222849381">"NV"</item>
  </string-array>
  <string-array name="cdma_subscription_values">
    <item msgid="2953825013895327785">"0"</item>
    <item msgid="7970797749269738435">"1"</item>
  </string-array>
    <string name="cdma_activate_device" msgid="5914720276140097632">"Activați dispozitivul"</string>
    <string name="cdma_lte_data_service" msgid="359786441782404562">"Configurați serviciul de date"</string>
    <string name="carrier_settings_title" msgid="6292869148169850220">"Setări operator"</string>
    <string name="fdn" msgid="2545904344666098749">"Numere apeluri restricționate"</string>
    <string name="fdn_with_label" msgid="6412087553365709494">"Numere pentru apeluri restricționate (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="manage_fdn_list" msgid="3341716430375195441">"Listă NAR"</string>
    <string name="fdn_list_with_label" msgid="1409655283510382556">"Listă NAR (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="fdn_activation" msgid="2178637004710435895">"Activați NAR"</string>
    <string name="fdn_enabled" msgid="7017355494808056447">"Numerele cu apelări restricționate sunt activate"</string>
    <string name="fdn_disabled" msgid="6696468878037736600">"Numerele pentru apeluri restricționate sunt dezactivate"</string>
    <string name="enable_fdn" msgid="4830555730418033723">"Activați NAR"</string>
    <string name="disable_fdn" msgid="3918794950264647541">"Dezactivați NAR"</string>
    <string name="change_pin2" msgid="3110844547237754871">"Schimbați codul PIN2"</string>
    <string name="enable_fdn_ok" msgid="5080925177369329827">"Dezactivați NAR"</string>
    <string name="disable_fdn_ok" msgid="3745475926874838676">"Activați NAR"</string>
    <string name="sum_fdn" msgid="6152246141642323582">"Gestionați numerele cu apelări restricționate"</string>
    <string name="sum_fdn_change_pin" msgid="3510994280557335727">"Schimbați codul PIN pentru acces la NAR"</string>
    <string name="sum_fdn_manage_list" msgid="3311397063233992907">"Gestionați lista numerelor de telefon"</string>
    <string name="voice_privacy" msgid="7346935172372181951">"Confidențialitate voce"</string>
    <string name="voice_privacy_summary" msgid="3556460926168473346">"Activați modul avansat de confidențialitate"</string>
    <string name="tty_mode_option_title" msgid="3843817710032641703">"Mod TTY"</string>
    <string name="tty_mode_option_summary" msgid="4770510287236494371">"Setați modul TTY"</string>
    <string name="auto_retry_mode_title" msgid="2985801935424422340">"Reîncercare automată"</string>
    <string name="auto_retry_mode_summary" msgid="2863919925349511402">"Activați modul Reîncercare automată"</string>
    <string name="tty_mode_not_allowed_video_call" msgid="6551976083652752815">"Schimbarea modului TTY nu este permisă în timpul unui apel video"</string>
    <string name="menu_add" msgid="5616487894975773141">"Adăugați o persoană"</string>
    <string name="menu_edit" msgid="3593856941552460706">"Modificați informațiile despre persoana din agendă"</string>
    <string name="menu_delete" msgid="6326861853830546488">"Ștergeți persoana din agendă"</string>
    <string name="menu_dial" msgid="4178537318419450012">"Apelați persoana de contact"</string>
    <string name="get_pin2" msgid="4221654606863196332">"Introduceți codul PIN2"</string>
    <string name="name" msgid="1347432469852527784">"Nume"</string>
    <string name="number" msgid="1564053487748491000">"Număr"</string>
    <string name="save" msgid="983805790346099749">"Salvați"</string>
    <string name="add_fdn_contact" msgid="1169713422306640887">"Adăugați un număr cu apelări restricționate"</string>
    <string name="adding_fdn_contact" msgid="3112531600824361259">"Se adaugă numărul cu apelări restricționate..."</string>
    <string name="fdn_contact_added" msgid="2840016151693394596">"Număr cu apelări restricționate adăugat."</string>
    <string name="edit_fdn_contact" msgid="6030829994819587408">"Modificați numărul cu apelări restricționate"</string>
    <string name="updating_fdn_contact" msgid="6989341376868227150">"Se actualizează numărul cu apelări restricționate..."</string>
    <string name="fdn_contact_updated" msgid="6876330243323118937">"Număr cu apelări restricționate actualizat."</string>
    <string name="delete_fdn_contact" msgid="7027405651994507077">"Ștergeți numărul cu apelări restricționate"</string>
    <string name="deleting_fdn_contact" msgid="6872320570844460428">"Se șterge numărul cu apelări restricționate..."</string>
    <string name="fdn_contact_deleted" msgid="1680714996763848838">"Numărul cu apelări restricționate a fost șters."</string>
    <string name="pin2_invalid" msgid="2313954262684494442">"NAR nu a fost actualizat, deoarece ați introdus un cod PIN incorect."</string>
    <string name="fdn_invalid_number" msgid="9067189814657840439">"NAR nu a fost actualizat deoarece numărul depășește <xliff:g id="FDN_NUMBER_LIMIT_LENGTH">%d</xliff:g> cifre."</string>
    <string name="pin2_or_fdn_invalid" msgid="7542639487955868181">"NAR nu a fost actualizat. Codul PIN2 a fost incorect sau numărul de telefon a fost respins."</string>
    <string name="fdn_failed" msgid="216592346853420250">"Operațiunea NAR nu a reușit."</string>
    <string name="simContacts_emptyLoading" msgid="4989040293858675483">"Se citește de pe cardul SIM..."</string>
    <string name="simContacts_empty" msgid="1135632055473689521">"Nicio persoană pe cardul SIM."</string>
    <string name="simContacts_title" msgid="2714029230160136647">"Selectați pentru import"</string>
    <string name="simContacts_airplaneMode" msgid="4654884030631503808">"Pentru a importa persoane de contact de pe cardul SIM, dezactivați modul Avion."</string>
    <string name="enable_pin" msgid="967674051730845376">"Activați/dezactivați codul PIN al cardului SIM"</string>
    <string name="change_pin" msgid="3657869530942905790">"Schimbați codul PIN pentru SIM"</string>
    <string name="enter_pin_text" msgid="3182311451978663356">"Codul PIN pentru cardul SIM:"</string>
    <string name="oldPinLabel" msgid="8618515202411987721">"Codul PIN vechi"</string>
    <string name="newPinLabel" msgid="3585899083055354732">"Cod PIN nou"</string>
    <string name="confirmPinLabel" msgid="7783531218662473778">"Confirmați noul cod PIN"</string>
    <string name="badPin" msgid="4549286285015892321">"Codul PIN vechi pe care l-ați introdus nu este corect. Încercați din nou."</string>
    <string name="mismatchPin" msgid="1467254768290323845">"Codurile PIN introduse nu se potrivesc. Încercați din nou."</string>
    <string name="invalidPin" msgid="7363723429414001979">"Introduceți un cod PIN alcătuit din 4 până la 8 cifre."</string>
    <string name="disable_sim_pin" msgid="3112303905548613752">"Ștergeți codul PIN pentru SIM"</string>
    <string name="enable_sim_pin" msgid="445461050748318980">"Setați codul PIN pentru SIM"</string>
    <string name="enable_in_progress" msgid="4135305985717272592">"Se setează codul PIN…"</string>
    <string name="enable_pin_ok" msgid="2877428038280804256">"Cod PIN setat"</string>
    <string name="disable_pin_ok" msgid="888505244389647754">"Cod PIN șters"</string>
    <string name="pin_failed" msgid="4527347792881939652">"Codul PIN nu este corect"</string>
    <string name="pin_changed" msgid="7291153750090452808">"Codul PIN a fost actualizat"</string>
    <string name="puk_requested" msgid="2061337960609806851">"Parola nu este corectă. Codul PIN a fost blocat. Se solicită codul PUK."</string>
    <string name="enter_pin2_text" msgid="7266379426804295979">"PIN2"</string>
    <string name="oldPin2Label" msgid="4648543187859997203">"Codul PIN2 vechi"</string>
    <string name="newPin2Label" msgid="1840905981784453939">"Cod PIN2 nou"</string>
    <string name="confirmPin2Label" msgid="4336025914667593762">"Confirmați noul cod PIN2"</string>
    <string name="badPuk2" msgid="6438182906645832235">"Codul PUK2 nu este corect. Încercați din nou."</string>
    <string name="badPin2" msgid="2760917538643074635">"Vechiul cod PIN2 nu este corect. Încercați din nou."</string>
    <string name="mismatchPin2" msgid="4952718725266700631">"Codurile PIN2 nu se potrivesc. Încercați din nou."</string>
    <string name="invalidPin2" msgid="6467957903056379343">"Introduceți un cod PIN2 format din 4 până la 8 cifre."</string>
    <string name="invalidPuk2" msgid="713729511903849544">"Introduceți un cod PUK2 format din 8 cifre."</string>
    <string name="pin2_changed" msgid="5710551850481287821">"Codul PIN2 a fost actualizat"</string>
    <string name="label_puk2_code" msgid="2852217004288085562">"Introduceți codul PUK2"</string>
    <string name="fdn_enable_puk2_requested" msgid="5793652792131588041">"Parola nu este corectă. Codul PIN2 a fost blocat. Pentru a încerca din nou, schimbați codul PIN2."</string>
    <string name="puk2_requested" msgid="6992374450720307514">"Parola nu este corectă. Cardul SIM a fost blocat. Introduceți codul PUK2."</string>
    <string name="puk2_blocked" msgid="3131139031779319911">"Codul PUK2 este blocat definitiv."</string>
    <string name="pin2_attempts" msgid="5625178102026453023">\n"V-au rămas <xliff:g id="NUMBER">%d</xliff:g> (de) încercări."</string>
    <string name="pin2_unblocked" msgid="4481107908727789303">"Codul PIN2 nu mai este blocat"</string>
    <string name="pin2_error_exception" msgid="8116103864600823641">"Eroare de rețea sau de card SIM"</string>
    <string name="doneButton" msgid="7371209609238460207">"Terminat"</string>
    <string name="voicemail_settings_number_label" msgid="1265118640154688162">"Număr de mesagerie vocală"</string>
    <string name="card_title_dialing" msgid="8742182654254431781">"Apelează"</string>
    <string name="card_title_redialing" msgid="18130232613559964">"Se reapelează"</string>
    <string name="card_title_conf_call" msgid="901197309274457427">"Teleconferință"</string>
    <string name="card_title_incoming_call" msgid="881424648458792430">"Apel primit"</string>
    <string name="card_title_call_ended" msgid="650223980095026340">"Apel încheiat"</string>
    <string name="card_title_on_hold" msgid="9028319436626975207">"În așteptare"</string>
    <string name="card_title_hanging_up" msgid="814874106866647871">"Se închide telefonul"</string>
    <string name="card_title_in_call" msgid="8231896539567594265">"În timpul apelului"</string>
    <string name="notification_voicemail_title" msgid="3932876181831601351">"Mesaj vocal nou"</string>
    <string name="notification_voicemail_title_count" msgid="2806950319222327082">"Mesaj vocal nou (<xliff:g id="COUNT">%d</xliff:g>)"</string>
    <string name="notification_voicemail_text_format" msgid="5720947141702312537">"Apelați <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
    <string name="notification_voicemail_no_vm_number" msgid="3423686009815186750">"Număr mesagerie vocală necunoscut"</string>
    <string name="notification_network_selection_title" msgid="255595526707809121">"Fără serviciu"</string>
    <string name="notification_network_selection_text" msgid="553288408722427659">"Rețeaua selectată (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nu este disponibilă"</string>
    <string name="incall_error_power_off" product="watch" msgid="7191184639454113633">"Activați rețeaua mobilă, dezactivați modul avion sau modul de economisire a bateriei pentru a iniția un apel."</string>
    <string name="incall_error_power_off" product="default" msgid="8131672264311208673">"Pentru a apela, dezactivați modul Avion."</string>
    <string name="incall_error_power_off_wfc" msgid="9125661184694727052">"Pentru a apela, dezactivați modul Avion sau conectați-vă la o rețea wireless."</string>
    <string name="incall_error_ecm_emergency_only" msgid="5622379058883722080">"Ieșiți din modul de apelare inversă de urgență pentru a efectua un apel care nu este de urgență."</string>
    <string name="incall_error_emergency_only" msgid="8786127461027964653">"Neînregistrat în rețea."</string>
    <string name="incall_error_out_of_service" msgid="1927265196942672791">"Rețeaua mobilă nu este disponibilă."</string>
    <string name="incall_error_out_of_service_wfc" msgid="4497663185857190885">"Rețeaua mobilă nu este disponibilă. Pentru a apela, conectați-vă la o rețea wireless."</string>
    <string name="incall_error_no_phone_number_supplied" msgid="8680831089508851894">"Pentru a apela, introduceți un număr valid."</string>
    <string name="incall_error_call_failed" msgid="393508653582682539">"Apelul nu a fost inițiat."</string>
    <string name="incall_error_cannot_add_call" msgid="5425764862628655443">"Apelul nu poate fi inițiat în acest moment. Puteți lua legătura cu persoana respectivă trimițându-i un mesaj."</string>
    <string name="incall_error_supp_service_unknown" msgid="8751177117194592623">"Serviciul nu este compatibil"</string>
    <string name="incall_error_supp_service_switch" msgid="5272822448189448479">"Apelurile nu pot fi comutate."</string>
    <string name="incall_error_supp_service_resume" msgid="1276861499306817035">"Nu se poate relua apelul."</string>
    <string name="incall_error_supp_service_separate" msgid="8932660028965274353">"Apelul nu poate fi separat."</string>
    <string name="incall_error_supp_service_transfer" msgid="8211925891867334323">"Nu se poate transfera."</string>
    <string name="incall_error_supp_service_conference" msgid="27578082433544702">"Nu se pot îmbina apelurile."</string>
    <string name="incall_error_supp_service_reject" msgid="3044363092441655912">"Apelul nu poate fi respins."</string>
    <string name="incall_error_supp_service_hangup" msgid="836524952243836735">"Apelurile nu pot fi eliberate."</string>
    <string name="incall_error_supp_service_hold" msgid="8535056414643540997">"Apelurile nu pot fi puse în așteptare."</string>
    <string name="incall_error_wfc_only_no_wireless_network" msgid="5860742792811400109">"Pentru a apela, conectați-vă la o rețea wireless."</string>
    <string name="incall_error_promote_wfc" msgid="9164896813931363415">"Activați apelarea prin Wi-Fi pentru a iniția un apel."</string>
    <string name="emergency_information_hint" msgid="9208897544917793012">"Informații în caz de urgență"</string>
    <string name="emergency_information_owner_hint" msgid="6256909888049185316">"Proprietar"</string>
    <string name="emergency_information_confirm_hint" msgid="5109017615894918914">"Atingeți din nou pentru a vedea informațiile"</string>
    <string name="emergency_enable_radio_dialog_title" msgid="2667568200755388829">"Apel de urgență"</string>
    <string name="single_emergency_number_title" msgid="8413371079579067196">"Număr de urgență"</string>
    <string name="numerous_emergency_numbers_title" msgid="8972398932506755510">"Numere de urgență"</string>
    <string name="emergency_call_shortcut_hint" msgid="1290485125107779500">"Atingeți din nou pentru a apela <xliff:g id="EMERGENCY_NUMBER">%s</xliff:g>"</string>
    <string name="emergency_enable_radio_dialog_message" msgid="1695305158151408629">"Se activează semnalul radio..."</string>
    <string name="emergency_enable_radio_dialog_retry" msgid="4329131876852608587">"Fără semnal. Se încearcă din nou..."</string>
    <string name="radio_off_during_emergency_call" msgid="8011154134040481609">"Nu se poate intra în modul avion în timpul unui apel de urgență."</string>
    <string name="dial_emergency_error" msgid="825822413209026039">"Nu se poate apela. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nu este un număr de urgență."</string>
    <string name="dial_emergency_empty_error" msgid="2785803395047793634">"Nu se poate apela. Formați un număr de urgență."</string>
    <string name="dial_emergency_calling_not_available" msgid="6485846193794727823">"Apelurile de urgență nu sunt disponibile."</string>
    <string name="pin_puk_system_user_only" msgid="1045147220686867922">"Numai proprietarul dispozitivului poate să introducă respectivele coduri PIN/PUK."</string>
    <string name="police_type_description" msgid="2819533883972081757">"Poliție"</string>
    <string name="ambulance_type_description" msgid="6798237503553180461">"Ambulanță"</string>
    <string name="fire_type_description" msgid="6565200468934914930">"Pompieri"</string>
    <string name="description_concat_format" msgid="2014471565101724088">"%1$s, %2$s"</string>
    <string name="dialerKeyboardHintText" msgid="1115266533703764049">"Utilizați tastatura pentru a forma"</string>
    <string name="onscreenHoldText" msgid="4025348842151665191">"Rețineți"</string>
    <string name="onscreenEndCallText" msgid="6138725377654842757">"Terminat"</string>
    <string name="onscreenShowDialpadText" msgid="658465753816164079">"Tastatură numerică"</string>
    <string name="onscreenMuteText" msgid="5470306116733843621">"Dezactivați sunetul"</string>
    <string name="onscreenAddCallText" msgid="9075675082903611677">"Adăugați un apel"</string>
    <string name="onscreenMergeCallsText" msgid="3692389519611225407">"Îmbinați apelurile"</string>
    <string name="onscreenSwapCallsText" msgid="2682542150803377991">"Schimbați"</string>
    <string name="onscreenManageCallsText" msgid="1162047856081836469">"Gestionați apelurile"</string>
    <string name="onscreenManageConferenceText" msgid="4700574060601755137">"Gestion. conferința"</string>
    <string name="onscreenAudioText" msgid="7224226735052019986">"Audio"</string>
    <string name="onscreenVideoCallText" msgid="1743992456126258698">"Apel video"</string>
    <string name="importSimEntry" msgid="3892354284082689894">"Importați"</string>
    <string name="importAllSimEntries" msgid="2628391505643564007">"Importați-le pe toate"</string>
    <string name="importingSimContacts" msgid="4995457122107888932">"Se importă persoanele din agenda de pe cardul SIM"</string>
    <string name="importToFDNfromContacts" msgid="5068664870738407341">"Importați din Agendă"</string>
    <string name="singleContactImportedMsg" msgid="3619804066300998934">"Persoana de contact a fost importată"</string>
    <string name="failedToImportSingleContactMsg" msgid="228095510489830266">"Persoana de contact nu a fost importată"</string>
    <string name="hac_mode_title" msgid="4127986689621125468">"Aparate auditive"</string>
    <string name="hac_mode_summary" msgid="7774989500136009881">"Activați compatibilitatea cu aparatele auditive"</string>
    <string name="rtt_mode_title" msgid="3075948111362818043">"Apel de tipul Text în timp real (TTR)"</string>
    <string name="rtt_mode_summary" msgid="8631541375609989562">"Permiteți schimbul de mesaje în timpul unui apel vocal"</string>
    <string name="rtt_mode_more_information" msgid="587500128658756318">"TTR oferă asistență apelanților fără auz, cu deficiențe de auz, care au dizabilități de vorbire sau care au nevoie de mai mult decât de voce.&lt;br&gt; &lt;a href=<xliff:g id="URL">http://support.google.com/mobile?p=telephony_rtt</xliff:g>&gt;Aflați mai multe&lt;/a&gt;\n       &lt;br&gt;&lt;br&gt; - Apelurile RTT sunt salvate ca transcrierea unui mesaj\n       &lt;br&gt; - Serviciul TTR nu este disponibil pentru apelurile video."</string>
    <string name="no_rtt_when_roaming" msgid="5268008247378355389">"Notă: funcția TTR nu este disponibilă când sunteți în roaming"</string>
  <string-array name="tty_mode_entries">
    <item msgid="3238070884803849303">"TTY dezactivat"</item>
    <item msgid="1449091874731375214">"TTY integral"</item>
    <item msgid="1044179293199519425">"TTY HCO"</item>
    <item msgid="2131559553795606483">"TTY VCO"</item>
  </string-array>
    <string name="dtmf_tones_title" msgid="7874845461117175236">"Tonuri DTMF"</string>
    <string name="dtmf_tones_summary" msgid="2294822239899471201">"Setați lungimea tonurilor DTMF"</string>
  <string-array name="dtmf_tone_entries">
    <item msgid="2271798469250155310">"Normală"</item>
    <item msgid="6044210222666533564">"Lung"</item>
  </string-array>
    <string name="network_info_message" msgid="7599413947016532355">"Mesaj de rețea"</string>
    <string name="network_error_message" msgid="4271579424089326618">"Mesaj de eroare"</string>
    <string name="ota_title_activate" msgid="4049645324841263423">"Activați-vă telefonul"</string>
    <string name="ota_touch_activate" msgid="838764494319694754">"Pentru a vă activa serviciul de telefonie, trebuie să efectuați un apel special. \n\nDupă ce apăsați „Activați”, ascultați instrucțiunile furnizate pentru a vă activa telefonul."</string>
    <string name="ota_hfa_activation_title" msgid="3300556778212729671">"Se activează..."</string>
    <string name="ota_hfa_activation_dialog_message" msgid="7921718445773342996">"Serviciul de date mobile este în curs de activare pe telefonul dvs.\n\nAcest proces poate dura până la 5 minute."</string>
    <string name="ota_skip_activation_dialog_title" msgid="7666611236789203797">"Omiteți activarea?"</string>
    <string name="ota_skip_activation_dialog_message" msgid="6691722887019708713">"Dacă omiteți activarea, nu puteți efectua apeluri și nici nu vă puteți conecta la o rețea de date mobilă (deși vă puteți conecta la rețele Wi-Fi). Până veți activa telefonul, vi se va solicita să-l activați de fiecare dată când îl porniți."</string>
    <string name="ota_skip_activation_dialog_skip_label" msgid="5908029466817825633">"Omiteți"</string>
    <string name="ota_activate" msgid="7939695753665438357">"Activați"</string>
    <string name="ota_title_activate_success" msgid="1272135024761004889">"Telefonul este activat."</string>
    <string name="ota_title_problem_with_activation" msgid="7019745985413368726">"Problemă de activare"</string>
    <string name="ota_listen" msgid="2772252405488894280">"Urmăriți instrucțiunile rostite până când veți auzi că activarea este finalizată."</string>
    <string name="ota_speaker" msgid="1086766980329820528">"Difuzor"</string>
    <string name="ota_progress" msgid="8837259285255700132">"Se programează telefonul…"</string>
    <string name="ota_failure" msgid="5674217489921481576">"Telefonul nu a putut fi programat"</string>
    <string name="ota_successful" msgid="1106825981548107774">"Telefonul dvs. este acum activat. Poate să dureze până la 15 minute până la pornirea serviciului."</string>
    <string name="ota_unsuccessful" msgid="8531037653803955754">"Telefonul dvs. nu s-a activat. \nVă recomandăm să găsiți o zonă cu acoperire mai bună (lângă fereastră sau afară). \n\nPentru mai multe opțiuni, încercați din nou sau apelați serviciul pentru clienți."</string>
    <string name="ota_spc_failure" msgid="904092035241370080">"ERORI DE DEPĂȘIRE SPC"</string>
    <string name="ota_call_end" msgid="8657746378290737034">"Înapoi"</string>
    <string name="ota_try_again" msgid="6914781945599998550">"Încercați din nou"</string>
    <string name="ota_next" msgid="2041016619313475914">"Înainte"</string>
    <string name="ecm_exit_dialog" msgid="4200691880721429078">"EcmExitDialog"</string>
    <string name="phone_entered_ecm_text" msgid="8431238297843035842">"S-a activat modul de apelare inversă de urgență"</string>
    <string name="phone_in_ecm_notification_title" msgid="6825016389926367946">"Mod de apelare inversă de urgență"</string>
    <string name="phone_in_ecm_call_notification_text" msgid="653972232922670335">"Conexiune de date dezactivată"</string>
    <string name="phone_in_ecm_notification_complete_time" msgid="7341624337163082759">"Nicio conexiune de date până la <xliff:g id="COMPLETETIME">%s</xliff:g>"</string>
    <plurals name="alert_dialog_exit_ecm" formatted="false" msgid="5425906903766466743">
      <item quantity="few">Telefonul va fi în modul Apelare inversă de urgență pentru <xliff:g id="COUNT_1">%s</xliff:g> minute. Când telefonul este în acest mod, nu se poate folosi nicio aplicație care necesită o conexiune de date. Doriți să ieșiți acum?</item>
      <item quantity="other">Telefonul va fi în modul Apelare inversă de urgență pentru <xliff:g id="COUNT_1">%s</xliff:g> de minute. Când telefonul este în acest mod, nu se poate folosi nicio aplicație care necesită o conexiune de date. Doriți să ieșiți acum?</item>
      <item quantity="one">Telefonul va fi în modul Apelare inversă de urgență pentru <xliff:g id="COUNT_0">%s</xliff:g> minut. Când telefonul este în acest mod, nu se poate folosi nicio aplicație care necesită o conexiune de date. Doriți să ieșiți acum?</item>
    </plurals>
    <plurals name="alert_dialog_not_avaialble_in_ecm" formatted="false" msgid="1152682528741457004">
      <item quantity="few">Acțiunea selectată nu este disponibilă când telefonul este în modul Apelare inversă de urgență. Telefonul va fi în acest mod pentru <xliff:g id="COUNT_1">%s</xliff:g> minute. Doriți să ieșiți acum?</item>
      <item quantity="other">Acțiunea selectată nu este disponibilă când telefonul este în modul Apelare inversă de urgență. Telefonul va fi în acest mod pentru <xliff:g id="COUNT_1">%s</xliff:g> de minute. Doriți să ieșiți acum?</item>
      <item quantity="one">Acțiunea selectată nu este disponibilă când telefonul este în modul Apelare inversă de urgență. Telefonul va fi în acest mod pentru <xliff:g id="COUNT_0">%s</xliff:g> minut. Doriți să ieșiți acum?</item>
    </plurals>
    <string name="alert_dialog_in_ecm_call" msgid="1207545603149771978">"Acțiunea selectată nu este disponibilă în timpul efectuării unui apel de urgență."</string>
    <string name="progress_dialog_exiting_ecm" msgid="9159080081676927217">"Se iese din modul Apelare inversă de urgență"</string>
    <string name="alert_dialog_yes" msgid="3532525979632841417">"Da"</string>
    <string name="alert_dialog_no" msgid="1075632654085988420">"Nu"</string>
    <string name="alert_dialog_dismiss" msgid="1336356286354517054">"Renunțați"</string>
    <string name="phone_in_ecm_call_notification_text_without_data_restriction_hint" msgid="3747860785153531225">"Telefonul va fi în modul Apelare inversă de urgență"</string>
    <string name="phone_in_ecm_notification_complete_time_without_data_restriction_hint" msgid="3690292264812050858">"Până la <xliff:g id="COMPLETETIME">%s</xliff:g>"</string>
    <plurals name="alert_dialog_exit_ecm_without_data_restriction_hint" formatted="false" msgid="6477733043040328640">
      <item quantity="few">Telefonul va fi în modul Apelare inversă de urgență timp de <xliff:g id="COUNT_1">%s</xliff:g> minute.\nDoriți să ieșiți acum?</item>
      <item quantity="other">Telefonul va fi în modul Apelare inversă de urgență timp de <xliff:g id="COUNT_1">%s</xliff:g> de minute.\nDoriți să ieșiți acum?</item>
      <item quantity="one">Telefonul va fi în modul Apelare inversă de urgență timp de <xliff:g id="COUNT_0">%s</xliff:g> minut.\nDoriți să ieșiți acum?</item>
    </plurals>
    <string name="voicemail_provider" msgid="4158806657253745294">"Serviciu"</string>
    <string name="voicemail_settings" msgid="4451045613238972776">"Configurare"</string>
    <string name="voicemail_number_not_set" msgid="8831561283386938155">"&lt;Nesetat&gt;"</string>
    <string name="other_settings" msgid="8895088007393598447">"Alte setări de apel"</string>
    <string name="calling_via_template" msgid="1791323450703751750">"Se apelează prin <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="contactPhoto" msgid="7885089213135154834">"fotografie persoană din agendă"</string>
    <string name="goPrivate" msgid="4645108311382209551">"trecerea la modul privat"</string>
    <string name="selectContact" msgid="1527612842599767382">"selectarea unei persoane din agendă"</string>
    <string name="not_voice_capable" msgid="2819996734252084253">"Apelarea vocală nu este acceptată"</string>
    <string name="description_dial_button" msgid="8614631902795087259">"apelare"</string>
    <string name="description_dialpad_button" msgid="7395114120463883623">"afișați tastatura numerică"</string>
    <string name="pane_title_emergency_dialpad" msgid="3627372514638694401">"Tastatură pentru apeluri de urgență"</string>
    <string name="voicemail_visual_voicemail_switch_title" msgid="6610414098912832120">"Mesagerie vocală vizuală"</string>
    <string name="voicemail_set_pin_dialog_title" msgid="7005128605986960003">"Setați codul PIN"</string>
    <string name="voicemail_change_pin_dialog_title" msgid="4633077715231764435">"Schimbați codul PIN"</string>
    <string name="preference_category_ringtone" msgid="8787281191375434976">"Ton de apel și vibrare"</string>
    <string name="pstn_connection_service_label" msgid="9200102709997537069">"Carduri SIM încorporate"</string>
    <string name="enable_video_calling_title" msgid="7246600931634161830">"Activați apelurile video"</string>
    <string name="enable_video_calling_dialog_msg" msgid="7141478720386203540">"Pentru a activa apelarea video, trebuie să activați Modul 4G LTE îmbunătățit în setările pentru rețea."</string>
    <string name="enable_video_calling_dialog_settings" msgid="8697890611305307110">"Setări de rețea"</string>
    <string name="enable_video_calling_dialog_close" msgid="4298929725917045270">"Închideți"</string>
    <string name="sim_label_emergency_calls" msgid="9078241989421522310">"Apeluri de urgență"</string>
    <string name="sim_description_emergency_calls" msgid="5146872803938897296">"Numai apeluri de urgență"</string>
    <string name="sim_description_default" msgid="7474671114363724971">"Cardul SIM, slotul: <xliff:g id="SLOT_ID">%s</xliff:g>"</string>
    <string name="accessibility_settings_activity_title" msgid="7883415189273700298">"Accesibilitate"</string>
    <string name="status_hint_label_incoming_wifi_call" msgid="2606052595898044071">"Apel prin Wi-Fi de la"</string>
    <string name="status_hint_label_wifi_call" msgid="942993035689809853">"Apel prin Wi-Fi"</string>
    <string name="emergency_action_launch_hint" msgid="2762016865340891314">"Atingeți din nou pentru a deschide"</string>
    <string name="message_decode_error" msgid="1061856591500290887">"A apărut o eroare la decodificarea mesajului."</string>
    <string name="callFailed_cdma_activation" msgid="5392057031552253550">"Un card SIM a activat serviciul și a actualizat funcțiile de roaming ale telefonului."</string>
    <string name="callFailed_cdma_call_limit" msgid="1074219746093031412">"Prea multe apeluri active. Încheiați sau îmbinați apeluri existente înainte de a iniția unul nou."</string>
    <string name="callFailed_imei_not_accepted" msgid="7257903653685147251">"Nu v-ați conectat. Inserați un card SIM valid."</string>
    <string name="callFailed_wifi_lost" msgid="1788036730589163141">"Conexiunea Wi-Fi s-a pierdut. Apelul a fost încheiat."</string>
    <string name="dialFailed_low_battery" msgid="6857904237423407056">"Apelul video nu a putut fi inițiat din cauza epuizării bateriei."</string>
    <string name="callFailed_low_battery" msgid="4056828320214416182">"Apelul video s-a încheiat din cauza epuizării bateriei."</string>
    <string name="callFailed_emergency_call_over_wfc_not_available" msgid="5944309590693432042">"Apelurile de urgență inițiate prin apelarea prin Wi-Fi nu sunt disponibile în această locație."</string>
    <string name="callFailed_wfc_service_not_available_in_this_location" msgid="3624536608369524988">"Apelarea prin Wi-fi nu este disponibilă în această locație."</string>
    <string name="change_pin_title" msgid="3564254326626797321">"Schimbați codul PIN pentru mesageria vocală"</string>
    <string name="change_pin_continue_label" msgid="5177011752453506371">"Continuați"</string>
    <string name="change_pin_cancel_label" msgid="2301711566758827936">"Anulați"</string>
    <string name="change_pin_ok_label" msgid="6861082678817785330">"OK"</string>
    <string name="change_pin_enter_old_pin_header" msgid="853151335217594829">"Confirmați vechiul cod PIN"</string>
    <string name="change_pin_enter_old_pin_hint" msgid="8801292976275169367">"Introduceți codul PIN pentru mesageria vocală pentru a continua."</string>
    <string name="change_pin_enter_new_pin_header" msgid="4739465616733486118">"Setați un cod PIN nou"</string>
    <string name="change_pin_enter_new_pin_hint" msgid="2326038476516364210">"Codul PIN trebuie să aibă între <xliff:g id="MIN">%1$d</xliff:g> - <xliff:g id="MAX">%2$d</xliff:g> cifre."</string>
    <string name="change_pin_confirm_pin_header" msgid="2606303906320705726">"Confirmați codul PIN"</string>
    <string name="change_pin_confirm_pins_dont_match" msgid="305164501222587215">"Codurile PIN nu corespund"</string>
    <string name="change_pin_succeeded" msgid="2504705600693014403">"Codul PIN pentru mesageria vocală a fost actualizat"</string>
    <string name="change_pin_system_error" msgid="7772788809875146873">"Nu s-a putut seta codul PIN"</string>
    <string name="mobile_data_status_roaming_turned_off_subtext" msgid="6840673347416227054">"Roamingul de date este dezactivat."</string>
    <string name="mobile_data_status_roaming_turned_on_subtext" msgid="5615757897768777865">"Roamingul de date este activat."</string>
    <string name="mobile_data_status_roaming_without_plan_subtext" msgid="6536671968072284677">"În prezent, se folosește roaming. Este necesar un abonament de date."</string>
    <string name="mobile_data_status_roaming_with_plan_subtext" msgid="2576177169108123095">"În prezent, se folosește roaming. Abonamentul de date este activ."</string>
    <string name="mobile_data_status_no_plan_subtext" msgid="170331026419263657">"Ați epuizat abonamentul de date mobile."</string>
    <string name="mobile_data_activate_prepaid" msgid="4276738964416795596">"Ați epuizat abonamentul de date mobile."</string>
    <string name="mobile_data_activate_prepaid_summary" msgid="6846085278531605925">"Adăugați date mobile prin <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="mobile_data_activate_roaming_plan" msgid="922290995866269366">"Niciun abonament de roaming"</string>
    <string name="mobile_data_activate_roaming_plan_summary" msgid="5379228493306235969">"Adăugați un abonament de roaming prin <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="mobile_data_activate_footer" msgid="7895874069807204548">"Puteți adăuga un abonament de date mobile sau de roaming prin operatorul dvs., <xliff:g id="PROVIDER_NAME">%s</xliff:g>."</string>
    <string name="mobile_data_activate_diag_title" msgid="5401741936224757312">"Adăugați date?"</string>
    <string name="mobile_data_activate_diag_message" msgid="3527260988020415441">"Poate fi necesar să adăugați date prin <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="mobile_data_activate_button" msgid="1139792516354374612">"ADĂUGAȚI DATE"</string>
    <string name="mobile_data_activate_cancel_button" msgid="3530174817572005860">"ANULAȚI"</string>
    <string name="clh_card_title_call_ended_txt" msgid="5977978317527299698">"Apel încheiat"</string>
    <string name="clh_callFailed_powerOff_txt" msgid="8279934912560765361">"Modul Avion este activat"</string>
    <string name="clh_callFailed_simError_txt" msgid="5128538525762326413">"Nu se poate accesa cardul SIM"</string>
    <string name="clh_incall_error_out_of_service_txt" msgid="2736010617446749869">"Rețeaua mobilă nu este disponibilă"</string>
    <string name="clh_callFailed_unassigned_number_txt" msgid="141967660286695682">"A apărut o problemă legată de numărul de telefon pe care încercați să-l apelați. Cod de eroare 1."</string>
    <string name="clh_callFailed_no_route_to_destination_txt" msgid="4805015149822352308">"Nu s-a finalizat apelul. Cod de eroare 3."</string>
    <string name="clh_callFailed_channel_unacceptable_txt" msgid="4062754579408613021">"Nu s-a finalizat apelul. Cod de eroare 6."</string>
    <string name="clh_callFailed_operator_determined_barring_txt" msgid="4202077821465974286">"Nu s-a finalizat apelul. Cod de eroare 8."</string>
    <string name="clh_callFailed_normal_call_clearing_txt" msgid="5677987959062976462">"Nu s-a finalizat apelul. Cod de eroare 16."</string>
    <string name="clh_callFailed_user_busy_txt" msgid="8886432858568086854">"Utilizatorul este ocupat"</string>
    <string name="clh_callFailed_no_user_responding_txt" msgid="341100226919865128">"Utilizatorul nu răspunde"</string>
    <string name="clh_callFailed_user_alerting_txt" msgid="896082976264427969">"Nu s-a finalizat apelul. Cod de eroare 19."</string>
    <string name="clh_callFailed_call_rejected_txt" msgid="3439435671153341709">"Apelul a fost respins"</string>
    <string name="clh_callFailed_number_changed_txt" msgid="2868476949771441667">"Numărul a fost modificat"</string>
    <string name="clh_callFailed_pre_emption_txt" msgid="8887998866342162724">"Nu s-a finalizat apelul. Cod de eroare 25."</string>
    <string name="clh_callFailed_non_selected_user_clearing_txt" msgid="4804529874810197550">"Nu s-a finalizat apelul. Cod de eroare 26."</string>
    <string name="clh_callFailed_destination_out_of_order_txt" msgid="1130697076352728824">"Nu s-a finalizat apelul. Cod de eroare 27."</string>
    <string name="clh_callFailed_invalid_number_format_txt" msgid="3171016382987224989">"Format de număr nevalid (număr incomplet)"</string>
    <string name="clh_callFailed_facility_rejected_txt" msgid="1054386430010898993">"Nu s-a finalizat apelul. Cod de eroare 29."</string>
    <string name="clh_callFailed_response_to_STATUS_ENQUIRY_txt" msgid="2763172551412307536">"Nu s-a finalizat apelul. Cod de eroare 30."</string>
    <string name="clh_callFailed_normal_unspecified_txt" msgid="978119938935737419">"Nu s-a finalizat apelul. Cod de eroare 31."</string>
    <string name="clh_callFailed_no_circuit_available_txt" msgid="1519684050419134605">"Nu s-a finalizat apelul. Cod de eroare 34."</string>
    <string name="clh_callFailed_network_out_of_order_txt" msgid="8689826504394592289">"Nu s-a finalizat apelul. Cod de eroare 38."</string>
    <string name="clh_callFailed_temporary_failure_txt" msgid="5065091554509067874">"Nu s-a finalizat apelul. Cod de eroare 41."</string>
    <string name="clh_callFailed_switching_equipment_congestion_txt" msgid="8681599376741988769">"Nu s-a finalizat apelul. Cod de eroare 42."</string>
    <string name="clh_callFailed_access_information_discarded_txt" msgid="2476199425130545428">"Nu s-a finalizat apelul. Cod de eroare 43."</string>
    <string name="clh_callFailed_requested_circuit_txt" msgid="7497497808928490219">"Nu s-a finalizat apelul. Cod de eroare 44."</string>
    <string name="clh_callFailed_resources_unavailable_unspecified_txt" msgid="144010529672928445">"Nu s-a finalizat apelul. Cod de eroare 47."</string>
    <string name="clh_callFailed_quality_of_service_unavailable_txt" msgid="4650329342288289290">"Nu s-a finalizat apelul. Cod de eroare 49."</string>
    <string name="clh_callFailed_requested_facility_not_subscribed_txt" msgid="9107977008516882170">"Nu s-a finalizat apelul. Cod de eroare 50."</string>
    <string name="clh_callFailed_incoming_calls_barred_within_the_CUG_txt" msgid="501037491908315591">"Nu s-a finalizat apelul. Cod de eroare 55."</string>
    <string name="clh_callFailed_bearer_capability_not_authorized_txt" msgid="4344366517528362620">"Nu s-a finalizat apelul. Cod de eroare 57."</string>
    <string name="clh_callFailed_bearer_capability_not_presently_available_txt" msgid="1436957294571545381">"Nu s-a finalizat apelul. Cod de eroare 58."</string>
    <string name="clh_callFailed_service_or_option_not_available_unspecified_txt" msgid="2149878874722675428">"Nu s-a finalizat apelul. Cod de eroare 63."</string>
    <string name="clh_callFailed_bearer_service_not_implemented_txt" msgid="1074983013965612410">"Nu s-a finalizat apelul. Cod de eroare 65."</string>
    <string name="clh_callFailed_ACM_equal_to_or_greater_than_ACMmax_txt" msgid="7889034195264205333">"Nu s-a finalizat apelul. Cod de eroare 68."</string>
    <string name="clh_callFailed_requested_facility_not_implemented_txt" msgid="7996646684699167978">"Nu s-a finalizat apelul. Cod de eroare 69."</string>
    <string name="clh_callFailed_only_restricted_digital_information_bearer_capability_is_available_txt" msgid="2358958110447385682">"Nu s-a finalizat apelul. Cod de eroare 70."</string>
    <string name="clh_callFailed_service_or_option_not_implemented_unspecified_txt" msgid="3046428509531159481">"Nu s-a finalizat apelul. Cod de eroare 79."</string>
    <string name="clh_callFailed_invalid_transaction_identifier_value_txt" msgid="1727401871777396619">"Nu s-a finalizat apelul. Cod de eroare 81."</string>
    <string name="clh_callFailed_user_not_member_of_CUG_txt" msgid="442282135105229307">"Nu s-a finalizat apelul. Cod de eroare 87."</string>
    <string name="clh_callFailed_incompatible_destination_txt" msgid="5900394706344969020">"Nu s-a finalizat apelul. Cod de eroare 88."</string>
    <string name="clh_callFailed_invalid_transit_network_selection_txt" msgid="6274621838349037741">"Nu s-a finalizat apelul. Cod de eroare 91."</string>
    <string name="clh_callFailed_semantically_incorrect_message_txt" msgid="7000705190197981937">"Nu s-a finalizat apelul. Cod de eroare 95."</string>
    <string name="clh_callFailed_invalid_mandatory_information_txt" msgid="3609204152671052123">"Nu s-a finalizat apelul. Cod de eroare 96."</string>
    <string name="clh_callFailed_message_type_non_existent_or_not_implemented_txt" msgid="1552110431052032814">"Nu s-a finalizat apelul. Cod de eroare 97."</string>
    <string name="clh_callFailed_message_type_not_compatible_with_protocol_state_txt" msgid="7717048934226300032">"Nu s-a finalizat apelul. Cod de eroare 98."</string>
    <string name="clh_callFailed_information_element_non_existent_or_not_implemented_txt" msgid="8931396541061612169">"Nu s-a finalizat apelul. Cod de eroare 99."</string>
    <string name="clh_callFailed_conditional_IE_error_txt" msgid="4630685477888727741">"Nu s-a finalizat apelul. Cod de eroare 100."</string>
    <string name="clh_callFailed_message_not_compatible_with_protocol_state_txt" msgid="3014075977395922947">"Nu s-a finalizat apelul. Cod de eroare 101."</string>
    <string name="clh_callFailed_recovery_on_timer_expiry_txt" msgid="5637581978978731672">"Nu s-a finalizat apelul. Cod de eroare 102."</string>
    <string name="clh_callFailed_protocol_Error_unspecified_txt" msgid="9203320572562697755">"Nu s-a finalizat apelul. Cod de eroare 111."</string>
    <string name="clh_callFailed_interworking_unspecified_txt" msgid="7969686413930847182">"Nu s-a finalizat apelul. Cod de eroare 127."</string>
    <string name="labelCallBarring" msgid="4180377113052853173">"Restricționarea apelurilor"</string>
    <string name="sum_call_barring_enabled" msgid="5184331188926370824">"Activat"</string>
    <string name="sum_call_barring_disabled" msgid="5699448000600153096">"Dezactivat"</string>
    <string name="call_barring_baoc" msgid="7400892586336429326">"Toate apelurile efectuate"</string>
    <string name="call_barring_baoc_enabled" msgid="3131509193386668182">"Dezactivați blocarea tuturor apelurilor efectuate?"</string>
    <string name="call_barring_baoc_disabled" msgid="8534224684091141509">"Blocați toate apelurile efectuate?"</string>
    <string name="call_barring_baoic" msgid="8668125428666851665">"Apeluri internaționale efectuate"</string>
    <string name="call_barring_baoic_enabled" msgid="1203758092657630123">"Dezactivați blocarea apelurilor internaționale efectuate?"</string>
    <string name="call_barring_baoic_disabled" msgid="5656889339002997449">"Blocați apelurile internaționale efectuate?"</string>
    <string name="call_barring_baoicr" msgid="8566167764432343487">"Roaming pentru apeluri internaționale efectuate"</string>
    <string name="call_barring_baoicr_enabled" msgid="1615324165512798478">"Dezactivați blocarea apelurilor internaționale efectuate prin roaming?"</string>
    <string name="call_barring_baoicr_disabled" msgid="172010175248142831">"Blocați apelurile internaționale efectuate prin roaming?"</string>
    <string name="call_barring_baic" msgid="7941393541678658566">"Toate primite"</string>
    <string name="call_barring_baic_enabled" msgid="4357332358020337470">"Dezactivați blocarea tuturor apelurilor primite?"</string>
    <string name="call_barring_baic_disabled" msgid="2355945245938240958">"Blocați toate apelurile primite?"</string>
    <string name="call_barring_baicr" msgid="8712249337313034226">"Roaming pentru apeluri internaționale primite"</string>
    <string name="call_barring_baicr_enabled" msgid="64774270234828175">"Dezactivați blocarea toate apelurile internaționale primite prin roaming?"</string>
    <string name="call_barring_baicr_disabled" msgid="3488129262744027262">"Blocați roamingul pentru apeluri internaționale primite?"</string>
    <string name="call_barring_deactivate_all" msgid="7837931580047157328">"Dezactivați tot"</string>
    <string name="call_barring_deactivate_all_description" msgid="4474119585042121604">"Dezactivați toate setările de restricționare a apelurilor"</string>
    <string name="call_barring_deactivate_success" msgid="3545644320298275337">"Restricționarea apelurilor este dezactivată"</string>
    <string name="call_barring_change_pwd" msgid="1730691950940338387">"Schimbați parola"</string>
    <string name="call_barring_change_pwd_description" msgid="1274245130382054227">"Schimbați parola pentru restricționarea apelurilor"</string>
    <string name="call_barring_change_pwd_description_disabled" msgid="2911647051915343920">"Nu se poate schimba parola pentru restricționarea apelurilor"</string>
    <string name="call_barring_pwd_not_match" msgid="7638198747579019826">"Parolele nu se potrivesc"</string>
    <string name="call_barring_right_pwd_number" msgid="3860630926460851330">"Introduceți o parolă cu 4 cifre"</string>
    <string name="call_barring_change_pwd_success" msgid="1837437691277936903">"Parola a fost modificată"</string>
    <string name="call_barring_old_pwd" msgid="5500085633281388281">"Parolă veche"</string>
    <string name="call_barring_new_pwd" msgid="2515524903813227732">"Parolă nouă"</string>
    <string name="call_barring_confirm_pwd" msgid="7552526161616461858">"Confirmați parola"</string>
    <string name="messageCallBarring" msgid="5537730400652466912">"Introduceți parola"</string>
    <string name="call_barring_settings" msgid="4616607285790258919">"Setări de restricționare a apelurilor"</string>
    <string name="callFailed_NetworkBusy" msgid="5437103975842913681">"Rețeaua este ocupată. Încercați să apelați din nou mai târziu."</string>
    <string name="callFailed_NetworkCongested" msgid="6801283142342775380">"Rețeaua este aglomerată. Contactați operatorul de telefonie mobilă pentru a cere asistență."</string>
    <string name="supp_service_notification_call_deflected" msgid="4980942818105909813">"Apelul a fost deviat."</string>
    <string name="supp_service_notification_call_forwarded" msgid="7102930311735433088">"Apelul a fost redirecționat."</string>
    <string name="supp_service_notification_call_waiting" msgid="4577403881609445324">"Apelul este în așteptare."</string>
    <string name="supp_service_clir_suppression_rejected" msgid="6105737020194776121">"Blocarea numerelor este respinsă."</string>
    <string name="supp_service_closed_user_group_call" msgid="2811636666505250689">"Apel pentru grup închis de utilizatori"</string>
    <string name="supp_service_incoming_calls_barred" msgid="2034627421274447674">"Apelurile primite sunt restricționate."</string>
    <string name="supp_service_outgoing_calls_barred" msgid="5205725332394087112">"Apelurile efectuate sunt restricționate."</string>
    <string name="supp_service_call_forwarding_active" msgid="7910162960395132464">"Redirecționarea apelurilor este activă."</string>
    <string name="supp_service_additional_call_forwarded" msgid="8772753260008398632">"Apelul suplimentar a fost redirecționat."</string>
    <string name="supp_service_additional_ect_connected" msgid="8525934162945220237">"Apelul explicit a fost transferat."</string>
    <string name="supp_service_additional_ect_connecting" msgid="7046240728781222753">"Transferul apelului explicit este în desfășurare."</string>
    <string name="supp_service_call_on_hold" msgid="2836811319594503059">"Apel în așteptare"</string>
    <string name="supp_service_call_resumed" msgid="3786864005920743546">"S-a reluat apelul."</string>
    <string name="supp_service_deflected_call" msgid="7565979024562921707">"Apelul a fost deviat."</string>
    <string name="supp_service_forwarded_call" msgid="6475776013771821457">"Apel redirecționat"</string>
    <string name="supp_service_conference_call" msgid="4004193534408317148">"Vă conectați la conferința telefonică."</string>
    <string name="supp_service_held_call_released" msgid="2847835124639112410">"Apelul în așteptare a fost deconectat."</string>
    <string name="callFailed_otasp_provisioning_in_process" msgid="3345666183602879326">"Nu se poate iniția un apel, deoarece, momentan, are loc provizionarea dispozitivului."</string>
    <string name="callFailed_already_dialing" msgid="7250591188960691086">"Nu se poate iniția un apel când se efectuează deja alt apel."</string>
    <string name="callFailed_already_ringing" msgid="2376603543544289303">"Nu se poate iniția un apel când primiți un apel la care nu ați răspuns. Răspundeți sau respingeți apelul primit înainte de a iniția un apel nou."</string>
    <string name="callFailed_calling_disabled" msgid="5010992739401206283">"Nu se poate iniția un apel deoarece apelarea a fost dezactivată folosindu-se funcția de sistem ro.telephony.disable-call."</string>
    <string name="callFailed_too_many_calls" msgid="5379426826618582180">"Nu se poate iniția un apel când există deja două apeluri în desfășurare. Deconectați unul dintre ele sau îmbinați-le într-o conferință înainte de a iniția un apel nou."</string>
    <string name="supp_service_over_ut_precautions" msgid="2145018231396701311">"Pentru a folosi <xliff:g id="SUPP_SERVICE">%s</xliff:g>, datele mobile trebuie să fie activate. Puteți modifica acest lucru în setările rețelei mobile."</string>
    <string name="supp_service_over_ut_precautions_roaming" msgid="670342104569972327">"Pentru a folosi <xliff:g id="SUPP_SERVICE">%s</xliff:g>, datele mobile și roamingul de date trebuie să fie activate. Puteți modifica acest lucru în setările rețelei mobile."</string>
    <string name="supp_service_over_ut_precautions_dual_sim" msgid="5166866975550910474">"Pentru a folosi <xliff:g id="SUPP_SERVICE">%1$s</xliff:g>, datele mobile trebuie să fie activate pentru cardul SIM <xliff:g id="SIM_NUMBER">%2$d</xliff:g>. Puteți modifica acest lucru în setările rețelei mobile."</string>
    <string name="supp_service_over_ut_precautions_roaming_dual_sim" msgid="6627654855191817965">"Pentru a folosi <xliff:g id="SUPP_SERVICE">%1$s</xliff:g>, datele mobile și roamingul de date trebuie să fie activate pentru cardul SIM <xliff:g id="SIM_NUMBER">%2$d</xliff:g>. Puteți modifica acest lucru în setările rețelei mobile."</string>
    <string name="supp_service_over_ut_precautions_dialog_dismiss" msgid="5934541487903081652">"Închideți"</string>
    <string name="radio_info_data_connection_enable" msgid="6183729739783252840">"Activați conexiunea de date"</string>
    <string name="radio_info_data_connection_disable" msgid="6404751291511368706">"Dezactivați conexiunea de date"</string>
    <string name="volte_provisioned_switch_string" msgid="4812874990480336178">"Oferit de VoLTE"</string>
    <string name="vt_provisioned_switch_string" msgid="8295542122512195979">"Apelarea video este configurată"</string>
    <string name="wfc_provisioned_switch_string" msgid="3835004640321078988">"Apelarea prin Wi-Fi este configurată"</string>
    <string name="eab_provisioned_switch_string" msgid="4449676720736033035">"Setări configurate pentru EAB/prezență"</string>
    <string name="cbrs_data_switch_string" msgid="6060356430838077653">"Date CBRS"</string>
    <string name="dsds_switch_string" msgid="7564769822086764796">"Activați DSDS"</string>
    <string name="dsds_dialog_title" msgid="8494569893941847575">"Reporniți dispozitivul?"</string>
    <string name="dsds_dialog_message" msgid="4047480385678538850">"Trebuie să reporniți dispozitivul pentru a modifica setarea."</string>
    <string name="dsds_dialog_confirm" msgid="9032004888134129885">"Reporniți"</string>
    <string name="dsds_dialog_cancel" msgid="3245958947099586655">"Anulați"</string>
    <string name="radio_info_radio_power" msgid="8805595022160471587">"Alimentare radio celular"</string>
    <string name="radioInfo_menu_viewADN" msgid="4533179730908559846">"Afișați agenda de pe SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="1847236480527032061">"Afișați numerele pentru apeluri restricționate"</string>
    <string name="radioInfo_menu_viewSDN" msgid="2613431584522392842">"Vedeți numere de apelare de serviciu"</string>
    <string name="radioInfo_menu_getIMS" msgid="1950869267853198232">"Starea serviciului IMS"</string>
    <string name="radio_info_ims_reg_status_title" msgid="6875885401313992007">"Stare IMS"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="7095182114078864326">"Înregistrat"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="8045821447288876085">"Neînregistrat"</string>
    <string name="radio_info_ims_feature_status_available" msgid="6493200914756969292">"Disponibil"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="8930391136839759778">"Indisponibil"</string>
    <string name="radio_info_ims_reg_status" msgid="25582845222446390">"Înregistrare IMS: <xliff:g id="STATUS">%1$s</xliff:g>\nVoice prin LTE: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nVoce prin WiFi: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nApelare video: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nInterfață UT: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="45753418231446400">"În aria de acoperire"</string>
    <string name="radioInfo_service_out" msgid="287972405416142312">"În afara ariei de acoperire"</string>
    <string name="radioInfo_service_emergency" msgid="4763879891415016848">"Numai apeluri de urgență"</string>
    <string name="radioInfo_service_off" msgid="3456583511226783064">"Radio oprit"</string>
    <string name="radioInfo_roaming_in" msgid="3156335577793145965">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="1904547918725478110">"Nu se utilizează roamingul"</string>
    <string name="radioInfo_phone_idle" msgid="2191653783170757819">"Inactiv"</string>
    <string name="radioInfo_phone_ringing" msgid="8100354169567413370">"Sună"</string>
    <string name="radioInfo_phone_offhook" msgid="7564601639749936170">"Apel în desfășurare"</string>
    <string name="radioInfo_data_disconnected" msgid="8085447971880814541">"Deconectat"</string>
    <string name="radioInfo_data_connecting" msgid="925092271092152472">"Se conectează"</string>
    <string name="radioInfo_data_connected" msgid="7637335645634239508">"Conectat"</string>
    <string name="radioInfo_data_suspended" msgid="8695262782642002785">"Suspendat"</string>
    <string name="radioInfo_unknown" msgid="5401423738500672850">"Necunoscut"</string>
    <string name="radioInfo_display_packets" msgid="6794302192441084157">"pachete"</string>
    <string name="radioInfo_display_bytes" msgid="7701006329222413797">"byți"</string>
    <string name="radioInfo_display_dbm" msgid="7491944975710865703">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="2247752203249646956">"asu"</string>
    <string name="radioInfo_lac" msgid="3892986460272607013">"LAC"</string>
    <string name="radioInfo_cid" msgid="1423185536264406705">"CID"</string>
    <string name="radio_info_subid" msgid="6839966868621703203">"SubId actual:"</string>
    <string name="radio_info_dds" msgid="1122593144425697126">"SubId pentru SIM-ul de date prestabilit:"</string>
    <string name="radio_info_dl_kbps" msgid="2382922659525318726">"Lățime de bandă de descărcare (kbps):"</string>
    <string name="radio_info_ul_kbps" msgid="2102225400904799036">"Lățime de bandă de încărcare (kbps):"</string>
    <string name="radio_info_signal_location_label" msgid="6188435197086550049">"Informații despre localizarea celulei (învechite):"</string>
    <string name="radio_info_phy_chan_config" msgid="1277949603275436081">"Configurarea canalului fizic LTE:"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="670511448975997340">"Rata de actualizare a informațiilor despre celulă:"</string>
    <string name="radio_info_cellinfo_label" msgid="8199062974670377659">"Toate informațiile de măsurare despre celulă:"</string>
    <string name="radio_info_gprs_service_label" msgid="6819204246355412952">"Serviciu de date:"</string>
    <string name="radio_info_roaming_label" msgid="6636932886446857120">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="8947899706930120368">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="4526480903023362276">"Redirecționarea apelului:"</string>
    <string name="radio_info_ppp_resets_label" msgid="9131901102339077661">"Numărul de resetări PPP de la pornire:"</string>
    <string name="radio_info_current_network_label" msgid="3052098695239642450">"Rețeaua actuală:"</string>
    <string name="radio_info_ppp_received_label" msgid="5753592451640644889">"Date primite:"</string>
    <string name="radio_info_gsm_service_label" msgid="6443348321714241328">"Serviciu de voce:"</string>
    <string name="radio_info_signal_strength_label" msgid="5545444702102543260">"Puterea semnalului:"</string>
    <string name="radio_info_call_status_label" msgid="7693575431923095487">"Stare apel vocal:"</string>
    <string name="radio_info_ppp_sent_label" msgid="6542208429356199695">"Date trimise:"</string>
    <string name="radio_info_message_waiting_label" msgid="1886549432566952078">"Mesaj în așteptare:"</string>
    <string name="radio_info_phone_number_label" msgid="2533852539562512203">"Număr de telefon:"</string>
    <string name="radio_info_band_mode_label" msgid="23480556225515290">"Selectați banda radio"</string>
    <string name="radio_info_voice_network_type_label" msgid="2395347336419593265">"Tipul rețelei de voce:"</string>
    <string name="radio_info_data_network_type_label" msgid="8886597029237501929">"Tipul rețelei de date:"</string>
    <string name="phone_index_label" msgid="6222406512768964268">"Selectați indexul telefonului"</string>
    <string name="radio_info_set_perferred_label" msgid="7408131389363136210">"Setați tipul preferat de rețea:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="6951237885381284790">"Dați ping adresei IPv4 a numelui de gazdă (www.google.com):"</string>
    <string name="radio_info_ping_hostname_v6" msgid="2748637889486554603">"Dați ping adresei IPv6 a numelui de gazdă (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="1329583721088428238">"Test client HTTP:"</string>
    <string name="ping_test_label" msgid="448617502935719694">"Efectuați testul de ping"</string>
    <string name="radio_info_smsc_label" msgid="3749927072726033763">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="5141996256097115753">"Actualizați"</string>
    <string name="radio_info_smsc_refresh_label" msgid="8409923721451604560">"Actualizați"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="1394078554927787350">"Activați/dezactivați verificarea DNS"</string>
    <string name="oem_radio_info_label" msgid="2914167475119997456">"Informații/Setări caracteristice OEM"</string>
    <string name="radio_info_endc_available" msgid="4410653375290113436">"Disponibilă EN-DC:"</string>
    <string name="radio_info_dcnr_restricted" msgid="2469125498066960807">"Restricționată DCNR:"</string>
    <string name="radio_info_nr_available" msgid="1321318331361249997">"Disponibilă NR:"</string>
    <string name="radio_info_nr_state" msgid="1337571996788535356">"Stare NR:"</string>
    <string name="radio_info_nr_frequency" msgid="1201156032796584128">"Frecvență NR:"</string>
    <string name="band_mode_title" msgid="7988822920724576842">"Setați Modul bandă radio"</string>
    <string name="band_mode_loading" msgid="795923726636735967">"Se încarcă lista de benzi…"</string>
    <string name="band_mode_set" msgid="6657819412803771421">"Setați"</string>
    <string name="band_mode_failed" msgid="1707488541847192924">"Nereușit"</string>
    <string name="band_mode_succeeded" msgid="2230018000534761063">"Reușit"</string>
    <string name="phone_info_label" product="tablet" msgid="7477478709388477397">"Informații tabletă"</string>
    <string name="phone_info_label" product="default" msgid="1784175881556791433">"Informații despre telefon"</string>
    <string name="carrier_provisioning" msgid="2668065041869578376">"Informații despre provizionarea operatorului"</string>
    <string name="trigger_carrier_provisioning" msgid="1301829588620638234">"Declanșați provizionarea operatorului"</string>
</resources>
