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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="phoneAppLabel" product="tablet" msgid="8576272342240415145">"Të dhëna celulare"</string>
    <string name="phoneAppLabel" product="default" msgid="6790717591729922998">"Shërbimet e telefonit"</string>
    <string name="emergencyDialerIconLabel" msgid="7812140032168171053">"Formuesi i numrit të urgjencës"</string>
    <string name="phoneIconLabel" msgid="2331230813161304895">"Telefoni"</string>
    <string name="fdnListLabel" msgid="8630418672279521003">"Lista e FDN-ve"</string>
    <string name="unknown" msgid="6878797917991465859">"I panjohur"</string>
    <string name="private_num" msgid="6713286113000232309">"Numër privat"</string>
    <string name="payphone" msgid="4793877574636445118">"Telefon me pagesë"</string>
    <string name="onHold" msgid="9035493194749959955">"Në pritje"</string>
    <string name="mmiStarted" msgid="6347869857061147003">"Kodi MMI filloi"</string>
    <string name="ussdRunning" msgid="485588686340541690">"Kodi USSD po punon…"</string>
    <string name="mmiCancelled" msgid="2771923949751842276">"Kodi MMI u anulua"</string>
    <string name="cancel" msgid="5044513931633602634">"Anulo"</string>
    <string name="enter_input" msgid="1810529547726803893">"Mesazhi USSD duhet të jetë mes karaktereve <xliff:g id="MIN_LEN">%d</xliff:g> dhe <xliff:g id="MAX_LEN">%d</xliff:g>. Provo sërish."</string>
    <string name="manageConferenceLabel" msgid="4691922394301969053">"Menaxho telefonatën-konferencë"</string>
    <string name="ok" msgid="3811371167865772377">"Në rregull"</string>
    <string name="audio_mode_speaker" msgid="27649582100085266">"Altoparlant"</string>
    <string name="audio_mode_earpiece" msgid="4156527186373869107">"Kufje për vesh"</string>
    <string name="audio_mode_wired_headset" msgid="1465350758489175975">"Kufje me tel"</string>
    <string name="audio_mode_bluetooth" msgid="3047641300848211128">"Bluetooth"</string>
    <string name="wait_prompt_str" msgid="7601815427707856238">"Dëshiron t\'i dërgosh tonet e mëposhtme?\n"</string>
    <string name="pause_prompt_str" msgid="1789964702154314806">"Po dërgon tone\n"</string>
    <string name="send_button" msgid="4106860097497818751">"Dërgo"</string>
    <string name="pause_prompt_yes" msgid="3564467212025151797">"Po"</string>
    <string name="pause_prompt_no" msgid="6686238803236884877">"Jo"</string>
    <string name="wild_prompt_str" msgid="5543521676355533577">"Zëvendëso karakterin variabël me"</string>
    <string name="no_vm_number" msgid="4164780423805688336">"Mungon numri i postës zanore"</string>
    <string name="no_vm_number_msg" msgid="1300729501030053828">"Nuk ka numër të ruajtur në kartën SIM."</string>
    <string name="add_vm_number_str" msgid="4676479471644687453">"Shto numër"</string>
    <string name="voice_number_setting_primary_user_only" msgid="6596604364907022416">"Cilësimet e postës zanore mund të modifikohen vetëm nga \"Përdoruesi kryesor\""</string>
    <string name="puk_unlocked" msgid="2284912838477558454">"Karta jote SIM u zhbllokua. Telefoni yt po shkyçet..."</string>
    <string name="label_ndp" msgid="780479633159517250">"PIN-i i shkyçjes së rrjetit të kartës SIM"</string>
    <string name="sim_ndp_unlock_text" msgid="683628237760543009">"Shkyçe"</string>
    <string name="sim_ndp_dismiss_text" msgid="1604823375752456947">"Injoro"</string>
    <string name="requesting_unlock" msgid="6412629401033249351">"Po kërkon shkyçjen e rrjetit…"</string>
    <string name="unlock_failed" msgid="6490531697031504225">"Kërkesa për shkyçjen e rrjetit ishte e pasuksesshme."</string>
    <string name="unlock_success" msgid="6770085622238180152">"Shkyçja e rrjetit ishte e suksesshme."</string>
    <string name="mobile_network_settings_not_available" msgid="7355254462995117896">"Cilësimet e rrjetit celular nuk ofrohen për këtë përdorues"</string>
    <string name="labelGSMMore" msgid="5930842194056092106">"Cilësimet e telefonatës GSM"</string>
    <string name="labelGsmMore_with_label" msgid="2674012918829238901">"Cilësimet e telefonatës GSM (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="labelCDMAMore" msgid="1630676740428229339">"Cilësimet e telefonatës CDMA"</string>
    <string name="labelCdmaMore_with_label" msgid="6333588719319970399">"Cilësimet e telefonatës CDMA (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="apn_settings" msgid="9043423184895642077">"Emrat e pikës së qasjes"</string>
    <string name="settings_label" msgid="3876743539816984008">"Cilësimet e rrjetit"</string>
    <string name="phone_accounts" msgid="6376603393888116364">"Llogaritë e telefonatave"</string>
    <string name="phone_accounts_make_calls_with" msgid="1969188078933152231">"Kryej telefonata me"</string>
    <string name="phone_accounts_make_sip_calls_with" msgid="4677789312053828493">"Kryej telefonata SIP me"</string>
    <string name="phone_accounts_ask_every_time" msgid="4346499067149985702">"Pyet në fillim"</string>
    <string name="phone_accounts_default_account_label" msgid="4183772241814460014">"Nuk ka rrjet të arritshëm"</string>
    <string name="phone_accounts_settings_header" msgid="4141710640883261094">"Cilësimet"</string>
    <string name="phone_accounts_choose_accounts" msgid="5232948804226424002">"Zgjidh llogaritë"</string>
    <string name="phone_accounts_selection_header" msgid="1365215726106915865">"Llogari telefoni"</string>
    <string name="phone_accounts_add_sip_account" msgid="2023821743341923271">"Shto llogari SIP"</string>
    <string name="phone_accounts_configure_account_settings" msgid="1361715069911607109">"Konfiguro cilësimet e llogarisë"</string>
    <string name="phone_accounts_all_calling_accounts" msgid="207619531589278471">"Të gjitha llogaritë e telefonatave"</string>
    <string name="phone_accounts_all_calling_accounts_summary" msgid="8594186415822657011">"Zgjidh se cilat llogari mund të kryejnë telefonata"</string>
    <string name="wifi_calling" msgid="739018212480165598">"Telefonatë me Wi-Fi"</string>
    <string name="connection_service_default_label" msgid="1498481943805913754">"Shërbim i integruar lidhjeje"</string>
    <string name="voicemail" msgid="8693759337917898954">"Posta zanore"</string>
    <string name="voicemail_settings_with_label" msgid="152724978380748296">"Posta zanore (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="voicemail_abbreviated" msgid="2215592488517217448">"VM:"</string>
    <string name="voicemail_notifications_preference_title" msgid="4019728578955102213">"Njoftimet"</string>
    <string name="cell_broadcast_settings" msgid="8740238216690502563">"Transmetimet e urgjencës"</string>
    <string name="call_settings" msgid="6112441768261754562">"Cilësimet e telefonatës"</string>
    <string name="additional_gsm_call_settings" msgid="1391795981938800617">"Cilësimet shtesë"</string>
    <string name="additional_gsm_call_settings_with_label" msgid="1385241520708457376">"Cilësime shtesë (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="sum_gsm_call_settings" msgid="4076647190996778012">"Cilësimet e telefonatës \"vetëm GSM\""</string>
    <string name="additional_cdma_call_settings" msgid="8628958775721886909">"Cilësime shtesë CDMA për telefonata"</string>
    <string name="sum_cdma_call_settings" msgid="284753265979035549">"Cilësime shtesë të telefonatës \"vetëm CDMA\""</string>
    <string name="labelNwService" msgid="4699970172021870983">"Cilësimet e shërbimit të rrjetit"</string>
    <string name="labelCallerId" msgid="3888899447379069198">"ID-ja e telefonuesit"</string>
    <string name="sum_loading_settings" msgid="1826692909391168620">"Po ngarkon cilësimet..."</string>
    <string name="sum_hide_caller_id" msgid="1071407020290873782">"Numri është i fshehur në telefonatat dalëse"</string>
    <string name="sum_show_caller_id" msgid="6768534125447290401">"Numri është shfaqur në telefonatat dalëse"</string>
    <string name="sum_default_caller_id" msgid="1954518825510901365">"Përdor cilësimet e operatorit për të shfaqur numrin tim në telefonatat dalëse"</string>
    <string name="labelCW" msgid="6120513814915920200">"Pritja e telefonatave"</string>
    <string name="sum_cw_enabled" msgid="8083061901633671397">"Gjatë një telefonate, më sinjalizo për telefonata të reja hyrëse"</string>
    <string name="sum_cw_disabled" msgid="3648693907300104575">"Gjatë një telefonate, më sinjalizo për telefonata të reja hyrëse"</string>
    <string name="call_forwarding_settings" msgid="3378927671091537173">"Cilësimet e transferimit të telefonatës"</string>
    <string name="call_forwarding_settings_with_label" msgid="8569489414006897127">"Cilësimet e transferimit të telefonatës (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="labelCF" msgid="2574386948026924737">"Transferimi i telefonatës"</string>
    <string name="labelCFU" msgid="8147177368148660600">"Transfero gjithmonë"</string>
    <string name="messageCFU" msgid="3560082430662923687">"Përdor gjithmonë këtë numër"</string>
    <string name="sum_cfu_enabled_indicator" msgid="4014187342724130197">"Po transferon të gjitha telefonatat"</string>
    <string name="sum_cfu_enabled" msgid="2450052502198827927">"Transferim i të gjitha telefonatave te <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfu_enabled_no_number" msgid="6591985777096823616">"Numri nuk mund të përdoret"</string>
    <string name="sum_cfu_disabled" msgid="8384177689501334080">"Çaktivizuar"</string>
    <string name="labelCFB" msgid="6139853033106283172">"Kur është e zënë"</string>
    <string name="messageCFB" msgid="3711089705936187129">"Numri, nëse linja është e zënë"</string>
    <string name="sum_cfb_enabled" msgid="5984198104833116690">"Transferim te <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfb_disabled" msgid="4913145177320506827">"Çaktivizuar"</string>
    <string name="disable_cfb_forbidden" msgid="3506984333877998061">"Operatori yt nuk mbështet çaktivizimin e transferimit të telefonatës kur telefoni është i zënë."</string>
    <string name="labelCFNRy" msgid="1736067178393744351">"Kur nuk përgjigjet"</string>
    <string name="messageCFNRy" msgid="672317899884380374">"Numri, nëse nuk përgjigjet"</string>
    <string name="sum_cfnry_enabled" msgid="6955775691317662910">"Transferim te <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfnry_disabled" msgid="3884684060443538097">"Çaktivizuar"</string>
    <string name="disable_cfnry_forbidden" msgid="4308233959150658058">"Operatori yt nuk mbështet çaktivizimin e transferimit të telefonatës kur telefoni nuk përgjigjet."</string>
    <string name="labelCFNRc" msgid="2614827454402079766">"Kur është e paarritshme"</string>
    <string name="messageCFNRc" msgid="6380695421020295119">"Numri, nëse linja është e paarritshme"</string>
    <string name="sum_cfnrc_enabled" msgid="7010898346095497421">"Transferim te <xliff:g id="PHONENUMBER">{0}</xliff:g>"</string>
    <string name="sum_cfnrc_disabled" msgid="2684474391807469832">"Çaktivizuar"</string>
    <string name="disable_cfnrc_forbidden" msgid="5646361343094064333">"Operatori yt nuk mbështet çaktivizimin e transferimit të telefonatës kur telefoni është i paarritshëm."</string>
    <string name="updating_title" msgid="6146755386174019046">"Cilësimet e telefonatës"</string>
    <string name="call_settings_admin_user_only" msgid="4526094783818216374">"Cilësimet e telefonatës mund të ndryshohen vetëm nga administratori."</string>
    <string name="call_settings_with_label" msgid="3401177261468593519">"Cilësimet (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="error_updating_title" msgid="7970259216988931777">"Gabim në cilësimet e telefonatës"</string>
    <string name="reading_settings" msgid="1920291699287055284">"Po lexon cilësimet…"</string>
    <string name="updating_settings" msgid="8171225533884883252">"Po përditëson cilësimet…"</string>
    <string name="reverting_settings" msgid="4752151682666912828">"Po rikthen cilësimet…"</string>
    <string name="response_error" msgid="6674110501330139405">"Përgjigje e papritur nga rrjeti."</string>
    <string name="exception_error" msgid="7027667130619518211">"Gabim në rrjet ose në kartën SIM."</string>
    <string name="stk_cc_ss_to_dial_error" msgid="2816779198916570502">"Kërkesa SS është modifikuar në kërkesën DIAL."</string>
    <string name="stk_cc_ss_to_ussd_error" msgid="7490626178582654236">"Kërkesa SS është modifikuar në kërkesën USSD."</string>
    <string name="stk_cc_ss_to_ss_error" msgid="5057846756489053759">"Kërkesa SS është modifikuar në kërkesën e re SS."</string>
    <string name="fdn_check_failure" msgid="18200614306525434">"Cilësimi për numrat me telefonim të përzgjedhur të aplikacionit të telefonit tënd u aktivizua. Si rezultat, disa funksione që kanë të bëjnë me telefonimin nuk funksionojnë."</string>
    <string name="radio_off_error" msgid="2304459933248513376">"Aktivizo radion para se të shohësh këto cilësime."</string>
    <string name="close_dialog" msgid="2365884406356986917">"Në rregull"</string>
    <string name="enable" msgid="7248657275000173526">"Aktivizo"</string>
    <string name="disable" msgid="4678348128118573672">"Çaktivizo"</string>
    <string name="change_num" msgid="239476305819844391">"Përditëso"</string>
  <string-array name="clir_display_values">
    <item msgid="5560134294467334594">"E parazgjedhur nga rrjeti"</item>
    <item msgid="7876195870037833661">"Fshihe numrin"</item>
    <item msgid="1108394741608734023">"Shfaqe numrin"</item>
  </string-array>
    <string name="vm_changed" msgid="380744030726254139">"Numri i postës zanore ndryshoi"</string>
    <string name="vm_change_failed" msgid="3352934863246208918">"Nuk mundi ta ndryshonte numrin e postës zanore.\nKontakto operatorin tënd nëse problemi vazhdon."</string>
    <string name="fw_change_failed" msgid="5298103228470214665">"Nuk arriti ta ndryshonte numrin e transferimit.\nKontakto operatorin tënd nëse problemi vazhdon."</string>
    <string name="fw_get_in_vm_failed" msgid="8862896836093833973">"Nuk arriti ta gjente e të ruante cilësimet aktuale të numrit të transferimit.\nDëshiron të kalosh gjithsesi te ofruesi i ri?"</string>
    <string name="no_change" msgid="3186040086622435212">"Nuk u bë asnjë ndryshim."</string>
    <string name="sum_voicemail_choose_provider" msgid="59911196126278922">"Zgjidh shërbimin e postës zanore"</string>
    <string name="voicemail_default" msgid="2001233554889016880">"Operatori yt"</string>
    <string name="vm_change_pin_old_pin" msgid="7295220109886682573">"Kodi PIN i vjetër"</string>
    <string name="vm_change_pin_new_pin" msgid="5412922262839438097">"Kodi PIN i ri"</string>
    <string name="vm_change_pin_progress_message" msgid="3977357361934350336">"Prit..."</string>
    <string name="vm_change_pin_error_too_short" msgid="5974971097302710497">"Kodi i ri PIN është shumë i shkurtër."</string>
    <string name="vm_change_pin_error_too_long" msgid="8476870806115051865">"Kodi i ri PIN është shumë i gjatë."</string>
    <string name="vm_change_pin_error_too_weak" msgid="7883744811891784882">"Kodi i ri PIN është shumë i dobët. Një fjalëkalim i fortë nuk duhet të ketë rend të vazhdueshëm ose shifra të përsëritura."</string>
    <string name="vm_change_pin_error_mismatch" msgid="2754685537970757317">"Kodi PIN i vjetër nuk përputhet."</string>
    <string name="vm_change_pin_error_invalid" msgid="3972205462701668653">"Kodi PIN i ri përmban karaktere të pavlefshme."</string>
    <string name="vm_change_pin_error_system_error" msgid="6610603326230000207">"Kodi PIN nuk u ndryshua."</string>
    <string name="vvm_unsupported_message_format" msgid="11795090778411977">"Lloj mesazhi i pambështetur, telefono <xliff:g id="NUMBER">%s</xliff:g> për ta dëgjuar."</string>
    <string name="mobile_networks" msgid="5540397602919106177">"Cilësimet e rrjetit celular"</string>
    <string name="network_settings_title" msgid="514120489499925574">"Rrjeti celular"</string>
    <string name="label_available" msgid="1181658289009300430">"Rrjete të arritshme"</string>
    <string name="load_networks_progress" msgid="5230707536168902952">"Po kërkon..."</string>
    <string name="empty_networks_list" msgid="4249426905018815316">"Nuk u gjetën rrjete."</string>
    <string name="network_query_error" msgid="6828516148953325006">"Gabim gjatë kërkimit për rrjete."</string>
    <string name="register_on_network" msgid="9055203954040805084">"Po regjistron në <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="5613353860205691579">"Karta SIM nuk lejon lidhje me këtë rrjet."</string>
    <string name="connect_later" msgid="2308119155752343975">"Nuk mund të lidhet me këtë rrjet tani. Provo sërish më vonë."</string>
    <string name="registration_done" msgid="495135664535876612">"Regjistruar në rrjet."</string>
    <string name="select_automatically" msgid="1046727200631770962">"Zgjidh automatikisht rrjetin"</string>
    <string name="network_select_title" msgid="7733107364757544558">"Rrjeti"</string>
    <string name="register_automatically" msgid="6017849844573519637">"Regjistrim automatik…"</string>
    <string name="preferred_network_mode_title" msgid="2336624679902659306">"Lloji i preferuar i rrjetit"</string>
    <string name="preferred_network_mode_summary" msgid="1434820673166126609">"Ndrysho modalitetin e operimit të rrjetit"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4048082093347807230">"Lloji i preferuar i rrjetit"</string>
    <string name="forbidden_network" msgid="4384929668343563440">"(ndalohet)"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="8521677230113533809">"Modaliteti i preferuar i rrjetit: preferohet WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="3352445413437453511">"Modaliteti i preferuar i rrjetit: vetëm GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="2836897236221063413">"Modaliteti i preferuar i rrjetit: vetëm WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="3161255745326408587">"Modaliteti i preferuar i rrjetit: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="3175690187294334241">"Modaliteti i preferuar i rrjetit: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="8332063064712726618">"Modaliteti i preferuar i rrjetit: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="1309770926198634150">"Modaliteti i preferuar i rrjetit: vetëm CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="8472220691721269155">"Modaliteti i preferuar i rrjetit: vetëm EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="4726682079415227330">"Modaliteti i preferuar i rrjetit: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="574752287596469136">"Modaliteti i preferuar i rrjetit: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="8455358514068283935">"Modaliteti i preferuar i rrjetit: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="228702246343742853">"Modaliteti i preferuar i rrjetit: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_global_summary" msgid="1633134285545730364">"Modaliteti i preferuar i rrjetit: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="9180775701594742750">"Modaliteti i preferuar i rrjetit: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="633315028976225026">"Modaliteti i preferuar i rrjetit: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="3722647806454528426">"Modaliteti i preferuar i rrjetit: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="8021016193718678775">"Modaliteti i preferuar i rrjetit: TDSCDMA"</string>
  <string-array name="preferred_network_mode_choices">
    <item msgid="7886739962255042385">"LTE / WCDMA"</item>
    <item msgid="577652050447385699">"LTE"</item>
    <item msgid="6813597571293773656">"Global"</item>
    <item msgid="127064712132619032">"GSM/WCDMA/LTE"</item>
    <item msgid="1126767511633425977">"CDMA + LTE/EvDo"</item>
    <item msgid="6389676313771670660">"CDMA/EvDo/GSM/WCDMA"</item>
    <item msgid="545430093607698090">"Vetëm EvDo"</item>
    <item msgid="1508557726283094448">"CDMA pa EvDo"</item>
    <item msgid="4341433122263841224">"CDMA/EvDo automatik"</item>
    <item msgid="5958053792390386668">"GSM/WCDMA automatik"</item>
    <item msgid="7913148405605373434">"Vetëm WCDMA"</item>
    <item msgid="1524224863879435516">"Vetëm GSM"</item>
    <item msgid="3817924849415716259">"GSM/WCDMA i preferuar"</item>
  </string-array>
    <string name="call_category" msgid="5863978196309462052">"Po telefonon"</string>
    <string name="network_operator_category" msgid="4830701959205735636">"Rrjeti"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="522191650223239171">"Modaliteti i përparuar 4G LTE"</string>
    <string name="enhanced_4g_lte_mode_title_variant" msgid="4871126028907265406">"Telefonatë e avancuar"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="2332175070522125850">"Përdor shërbimet LTE për të përmirësuar komunikimet zanore dhe të tjera (rekomandohet)"</string>
    <string name="data_enabled" msgid="5972538663568715366">"Të dhënat janë të aktivizuara"</string>
    <string name="data_enable_summary" msgid="2382798156640007971">"Lejo përdorimin e të dhënave"</string>
    <string name="dialog_alert_title" msgid="6751344986194435476">"Kujdes!"</string>
    <string name="roaming" msgid="7894878421600247140">"Roaming"</string>
    <string name="roaming_enable" msgid="7331106985174381987">"Lidhu me shërbimet e të dhënave kur je në roaming"</string>
    <string name="roaming_disable" msgid="1843417228755568110">"Lidhu me shërbimin e të dhënave kur je në roaming"</string>
    <string name="roaming_reenable_message" msgid="8913735676127858115">"E humbët lidhjen e të dhënave sepse sapo latë rrjetin e vendit tuaj dhe tani jeni me të dhëna roaming-u, të cilat ende nuk janë aktivizuar."</string>
    <string name="roaming_warning" msgid="1603164667540144353">"Mund të shkaktohen tarifa të larta."</string>
    <string name="roaming_alert_title" msgid="3654815360303826008">"Të lejohet përdorimi i të dhënave kur je në roaming?"</string>
    <string name="data_usage_title" msgid="8759619109516889802">"Përdorimi i të dhënave"</string>
    <string name="data_usage_template" msgid="8526428824844656364">"<xliff:g id="ID_1">%1$s</xliff:g> të dhëna celulare të përdorura mes datave <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="advanced_options_title" msgid="8074895510265488035">"Të përparuara"</string>
    <string name="carrier_settings_euicc" msgid="6714062862127226405">"Operatori celular"</string>
    <string name="keywords_carrier_settings_euicc" msgid="783429609643157743">"operatori celular, esim, sim, euicc"</string>
    <string name="carrier_settings_euicc_summary" msgid="5115001942761995457">"<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="4661165467914727157">"Të dhënat celulare"</string>
    <string name="mobile_data_settings_summary" msgid="5087255915840576895">"Qasu te të dhënat duke përdorur rrjetin celular"</string>
    <string name="data_usage_disable_mobile" msgid="3577275288809667615">"Të çaktivizohen të dhënat celulare?"</string>
    <string name="sim_selection_required_pref" msgid="7049424902961844236">"Kërkohet përzgjedhja"</string>
    <string name="sim_change_data_title" msgid="5332425991853799280">"Të ndryshohet SIM për të dhënat?"</string>
    <string name="sim_change_data_message" msgid="2163963581444907496">"Të përdoret <xliff:g id="NEW_SIM">%1$s</xliff:g> në vend të <xliff:g id="OLD_SIM">%2$s</xliff:g> për të dhënat celulare?"</string>
    <string name="wifi_calling_settings_title" msgid="7741961465416430470">"Telefonata me Wi-Fi"</string>
    <string name="video_calling_settings_title" msgid="539714564273795574">"Telefonata me video e operatorit celular"</string>
    <string name="gsm_umts_options" msgid="6538311689850981686">"Opsionet GSM/UMTS"</string>
    <string name="cdma_options" msgid="4016822858172249884">"Opsionet CDMA"</string>
    <string name="throttle_data_usage" msgid="3715677828160555808">"Përdorimi i të dhënave"</string>
    <string name="throttle_current_usage" msgid="8762280193043815361">"Të dhënat e përdorura në periudhën aktuale"</string>
    <string name="throttle_time_frame" msgid="1915198770363734685">"Periudha e përdorimit të të dhënave"</string>
    <string name="throttle_rate" msgid="4710388992676803508">"Politika e shpejtësisë së të dhënave"</string>
    <string name="throttle_help" msgid="243651091785169900">"Mëso më shumë"</string>
    <string name="throttle_status_subtext" msgid="1657318943142085170">"<xliff:g id="USED_0">%1$s</xliff:g> (<xliff:g id="USED_1">%2$d</xliff:g>٪) nga maksimumi i periudhës prej <xliff:g id="USED_2">%3$s</xliff:g> \nPeriudha tjetër fillon për <xliff:g id="USED_3">%4$d</xliff:g> ditë (<xliff:g id="USED_4">%5$s</xliff:g>)"</string>
    <string name="throttle_data_usage_subtext" msgid="6029276011123694701">"<xliff:g id="USED_0">%1$s</xliff:g> (<xliff:g id="USED_1">%2$d</xliff:g>٪) nga maksimumi i periudhës prej <xliff:g id="USED_2">%3$s</xliff:g>"</string>
    <string name="throttle_data_rate_reduced_subtext" msgid="7492763592720107737">"U kapërcye maksimumi i <xliff:g id="USED_0">%1$s</xliff:g>\nShpejtësia e të dhënave u pakësua deri në <xliff:g id="USED_1">%2$d</xliff:g> Kb/s"</string>
    <string name="throttle_time_frame_subtext" msgid="7732763021560399960">"Ka kaluar <xliff:g id="USED_0">%1$d</xliff:g>٪ të ciklit\nPeriudha tjetër fillon për <xliff:g id="USED_1">%2$d</xliff:g> ditë (<xliff:g id="USED_2">%3$s</xliff:g>)"</string>
    <string name="throttle_rate_subtext" msgid="2149102656120726855">"Shpejtësia e të dhënave pakësohet në <xliff:g id="USED">%1$d</xliff:g> Kb/s nëse tejkalohet kufiri i përdorimit të të dhënave"</string>
    <string name="throttle_help_subtext" msgid="5217706521499010816">"Më shumë informacion rreth politikës së përdorimit të të dhënave të rrjetit celular të operatorit tënd"</string>
    <string name="cell_broadcast_sms" msgid="5584192824053625842">"SMS-ja e \"Transmetimit celular\""</string>
    <string name="enable_disable_cell_bc_sms" msgid="4851147873691392255">"SMS-ja e transmetimit celular"</string>
    <string name="cell_bc_sms_enable" msgid="6441688565738921084">"SMS-ja e \"Transmetimit celular\" është e aktivizuar"</string>
    <string name="cell_bc_sms_disable" msgid="3398365088309408749">"SMS-ja e \"Transmetimit celular\" është e çaktivizuar"</string>
    <string name="cb_sms_settings" msgid="651715019785107312">"Cilësimet e SMS-së së \"Transmetimit celular\""</string>
    <string name="enable_disable_emergency_broadcast" msgid="2157014609041245335">"Transmetimi i urgjencës"</string>
    <string name="emergency_broadcast_enable" msgid="2645980025414010211">"Transmetimi i urgjencës është i aktivizuar"</string>
    <string name="emergency_broadcast_disable" msgid="3665199821267569426">"Transmetimi i urgjencës është i çaktivizuar"</string>
    <string name="enable_disable_administrative" msgid="6501582322182059412">"Administrativi"</string>
    <string name="administrative_enable" msgid="1750086122962032235">"\"Administrativi\" u aktivizua"</string>
    <string name="administrative_disable" msgid="8433273857248698539">"\"Administrativi\" u çaktivizua"</string>
    <string name="enable_disable_maintenance" msgid="1819693083025106678">"Mirëmbajtje"</string>
    <string name="maintenance_enable" msgid="8566636458770971189">"Mirëmbajtja është e aktivizuar"</string>
    <string name="maintenance_disable" msgid="7340189100885066077">"Mirëmbajtja është e çaktivizuar"</string>
    <string name="general_news_settings" msgid="4968779723948432978">"Lajme të përgjithshme"</string>
    <string name="bf_news_settings" msgid="3935593091894685267">"Lajme nga fusha e biznesit dhe financës"</string>
    <string name="sports_news_settings" msgid="7649399631270052835">"Lajme sportive"</string>
    <string name="entertainment_news_settings" msgid="5051153952959405035">"Lajme argëtuese"</string>
    <string name="enable_disable_local" msgid="7890281063123416120">"Lokal"</string>
    <string name="local_enable" msgid="6370463247609136359">"Lajmet lokale janë të aktivizuara"</string>
    <string name="local_disable" msgid="4405691986943795798">"Lajmet lokale janë të çaktivizuara"</string>
    <string name="enable_disable_regional" msgid="4905652414535565872">"Rajonal"</string>
    <string name="regional_enable" msgid="4434680415437834759">"Lajmet rajonale u aktivizuan"</string>
    <string name="regional_disable" msgid="5359325527213850077">"Lajmet rajonale u çaktivizuan"</string>
    <string name="enable_disable_national" msgid="236278090206880734">"Kombëtar"</string>
    <string name="national_enable" msgid="1172443648912246952">"Lajmet kombëtare janë të aktivizuar"</string>
    <string name="national_disable" msgid="326018148178601166">"Lajmet kombëtare janë të çaktivizuara"</string>
    <string name="enable_disable_international" msgid="7535348799604565592">"Ndërkombëtare"</string>
    <string name="international_enable" msgid="5855356769925044927">"Lajmet ndërkombëtare janë të aktivizuara"</string>
    <string name="international_disable" msgid="2850648591041088931">"Lajmet ndërkombëtare janë të çaktivizuara"</string>
    <string name="list_language_title" msgid="2841683501919760043">"Gjuha"</string>
    <string name="list_language_summary" msgid="8109546531071241601">"Përzgjidh gjuhën e lajmeve"</string>
  <string-array name="list_language_entries">
    <item msgid="6137851079727305485">"anglisht"</item>
    <item msgid="1151988412809572526">"frëngjisht"</item>
    <item msgid="577840534704312665">"spanjisht"</item>
    <item msgid="8385712091143148180">"japonisht"</item>
    <item msgid="1858401628368130638">"koreanisht"</item>
    <item msgid="1933212028684529632">"kinezisht"</item>
    <item msgid="1908428006803639064">"hebraisht"</item>
  </string-array>
  <string-array name="list_language_values">
    <item msgid="1804908636436467150">"1"</item>
    <item msgid="289708030346890334">"2"</item>
    <item msgid="1121469729692402684">"3"</item>
    <item msgid="2614093115912897722">"4"</item>
    <item msgid="2411164639857960614">"5"</item>
    <item msgid="5884448729274543324">"6"</item>
    <item msgid="5511864807618312598">"7"</item>
  </string-array>
    <string name="list_language_dtitle" msgid="5442908726538951934">"Gjuhët"</string>
    <string name="enable_disable_local_weather" msgid="986967454867219114">"Moti lokal"</string>
    <string name="local_weather_enable" msgid="6199315114382448922">"Moti lokal është i aktivizuar"</string>
    <string name="local_weather_disable" msgid="2510158089142626480">"Moti lokal është i çaktivizuar"</string>
    <string name="enable_disable_atr" msgid="8339572391278872343">"Raportet e trafikut të zonës"</string>
    <string name="atr_enable" msgid="5541757457789181799">"Raportet e trafikut të zonës u aktivizuan"</string>
    <string name="atr_disable" msgid="7085558154727596455">"Raportet e trafikut të zonës u çaktivizuan"</string>
    <string name="enable_disable_lafs" msgid="668189073721277199">"Oraret e fluturimeve të aeroportit lokal"</string>
    <string name="lafs_enable" msgid="2791978667205137052">"Oraret e fluturimeve të aeroportit lokal janë të aktivizuara"</string>
    <string name="lafs_disable" msgid="2391212397725495350">"Oraret e fluturimeve të aeroportit lokal janë të çaktivizuara"</string>
    <string name="enable_disable_restaurants" msgid="6240381945336814024">"Restorante"</string>
    <string name="restaurants_enable" msgid="5137657479469118847">"Restorantet u aktivizuan"</string>
    <string name="restaurants_disable" msgid="3678480270938424092">"Restorantet u çaktivizuan"</string>
    <string name="enable_disable_lodgings" msgid="1822029172658551202">"Banesat"</string>
    <string name="lodgings_enable" msgid="3230042508992850322">"\"Banesat\" janë të aktivizuara"</string>
    <string name="lodgings_disable" msgid="3387879742320682391">"\"Banesat\" janë të çaktivizuara"</string>
    <string name="enable_disable_retail_directory" msgid="1357809784475660303">"Direktoria e shitjes me pakicë"</string>
    <string name="retail_directory_enable" msgid="3280626290436111496">"Direktoria e shitjeve me pakicë u aktivizua"</string>
    <string name="retail_directory_disable" msgid="6479739816662879027">"Direktoria e shitjeve me pakicë u çaktivizua"</string>
    <string name="enable_disable_advertisements" msgid="5999495926176182128">"Reklama"</string>
    <string name="advertisements_enable" msgid="2050305021264683786">"Reklamat u aktivizuan"</string>
    <string name="advertisements_disable" msgid="8350985908788707935">"Reklamat u çaktivizuan"</string>
    <string name="enable_disable_stock_quotes" msgid="6397810445293533603">"Kuotimet e bursës"</string>
    <string name="stock_quotes_enable" msgid="4384802470887170543">"Kuotimet e bursës u aktivizuan"</string>
    <string name="stock_quotes_disable" msgid="4781450084565594998">"Kuotimet e bursës u çaktivizuan"</string>
    <string name="enable_disable_eo" msgid="4863043263443942494">"Mundësitë e punësimit"</string>
    <string name="eo_enable" msgid="8623559062015685813">"\"Mundësitë e punësimit\" është i aktivizuar"</string>
    <string name="eo_disable" msgid="3863812478090907609">"\"Mundësitë e punësimit\" është i çaktivizuar"</string>
    <string name="enable_disable_mhh" msgid="908214593528968522">"Mjekësor, shëndetësor dhe spitalor"</string>
    <string name="mhh_enable" msgid="5544500632306446815">"\"Mjekësor, shëndetësor dhe spitalor\" është i aktivizuar"</string>
    <string name="mhh_disable" msgid="8998210550117117437">"\"Mjekësor, shëndetësor dhe spitalor\" është i çaktivizuar"</string>
    <string name="enable_disable_technology_news" msgid="3517184627114999149">"Lajme teknologjike"</string>
    <string name="technology_news_enable" msgid="7995209394210455181">"Lajmet teknologjike u aktivizuan"</string>
    <string name="technology_news_disable" msgid="5483490380561851946">"Lajmet teknologjike u çaktivizuan"</string>
    <string name="enable_disable_multi_category" msgid="626771003122899280">"Multi-kategoria"</string>
    <string name="multi_category_enable" msgid="1179299804641721768">"\"Multi-kategoria\" u aktivizua"</string>
    <string name="multi_category_disable" msgid="880104702904139505">"\"Multi-kategoria\" u çaktivizua"</string>
    <string name="network_lte" msgid="7702681952521375754">"LTE (rekomandohet)"</string>
    <string name="network_4G" msgid="2723512640529983138">"4G (rekomandohet)"</string>
    <string name="network_global" msgid="1323190488685355309">"Global"</string>
    <string name="cdma_system_select_title" msgid="5757657769327732833">"Përzgjedhje e sistemit"</string>
    <string name="cdma_system_select_summary" msgid="60460043745797517">"Ndrysho modalitetin CDMA të roaming-ut"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6083355415165359075">"Përzgjedhje e sistemit"</string>
  <string-array name="cdma_system_select_choices">
    <item msgid="176474317493999285">"Vetëm \"Ekranin bazë\""</item>
    <item msgid="1205664026446156265">"Automatik"</item>
  </string-array>
    <string name="cdma_subscription_title" msgid="1162564010076763284">"Abonimi CDMA"</string>
    <string name="cdma_subscription_summary" msgid="2530890766115781140">"Ndrysho mes RUIM/SIM dhe NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="2699527950523333110">"abonim"</string>
  <string-array name="cdma_subscription_choices">
    <item msgid="2258014151300708431">"RUIM/SIM"</item>
    <item msgid="5127722015571873880">"NV"</item>
  </string-array>
  <string-array name="cdma_subscription_values">
    <item msgid="7494167883478914080">"0"</item>
    <item msgid="6043847456049107742">"1"</item>
  </string-array>
    <string name="cdma_activate_device" msgid="3793805892364814518">"Aktivizo"</string>
    <string name="cdma_lte_data_service" msgid="4255018217292548962">"Konfiguro shërbimin e të dhënave"</string>
    <string name="carrier_settings_title" msgid="9028166176523012300">"Cilësimet e operatorit"</string>
    <string name="fdn" msgid="7878832555095183202">"Numrat me telefonim të përzgjedhur"</string>
    <string name="fdn_with_label" msgid="187084204115493366">"Numrat me telefonim të përzgjedhur (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="manage_fdn_list" msgid="8777755791892122369">"Lista e FDN-ve"</string>
    <string name="fdn_list_with_label" msgid="7437232552210469217">"Lista e FDN-së (<xliff:g id="SUBSCRIPTIONLABEL">%s</xliff:g>)"</string>
    <string name="fdn_activation" msgid="2156479741307463576">"Aktivizimi i FDN-së"</string>
    <string name="fdn_enabled" msgid="5238109009915521240">"Numrat me telefonim të përzgjedhur u aktivizuan"</string>
    <string name="fdn_disabled" msgid="4700049736675368279">"Numrat me telefonim të përzgjedhur u çaktivizuan"</string>
    <string name="enable_fdn" msgid="3740191529180493851">"Aktivizo FDN-në"</string>
    <string name="disable_fdn" msgid="7944020890722540616">"Çaktivizo FDN-në"</string>
    <string name="change_pin2" msgid="2153563695382176676">"Ndrysho PIN2-shin"</string>
    <string name="enable_fdn_ok" msgid="7215588870329688132">"Çaktivizo FDN-në"</string>
    <string name="disable_fdn_ok" msgid="5727046928930740173">"Aktivizo FDN-në"</string>
    <string name="sum_fdn" msgid="1959399454900272878">"Menaxho numrat me telefonim të përzgjedhur"</string>
    <string name="sum_fdn_change_pin" msgid="6666549734792827932">"Ndrysho PIN-in për qasje te FDN-ja"</string>
    <string name="sum_fdn_manage_list" msgid="8431088265332628316">"Menaxho listën e numrave të telefonit"</string>
    <string name="voice_privacy" msgid="3776841382844614716">"Privatësia e zërit"</string>
    <string name="voice_privacy_summary" msgid="3159383389833516214">"Aktivizo modalitetin e privatësisë së përparuar"</string>
    <string name="tty_mode_option_title" msgid="9033098925144434669">"Modaliteti TTY"</string>
    <string name="tty_mode_option_summary" msgid="1073835131534808732">"Cakto modalitetin TTY"</string>
    <string name="auto_retry_mode_title" msgid="4073265511427813322">"Ripërpjekja automatike"</string>
    <string name="auto_retry_mode_summary" msgid="4973886004067532288">"Aktivizo modalitetin e ripërpjekjes automatike"</string>
    <string name="tty_mode_not_allowed_video_call" msgid="3795846787901909176">"Nuk lejohet ndryshimi i modalitetit TTY gjatë telefonatave me video"</string>
    <string name="menu_add" msgid="1882023737425114762">"Shto kontakt"</string>
    <string name="menu_edit" msgid="7143003705504672374">"Redakto kontaktin"</string>
    <string name="menu_delete" msgid="3977150783449642851">"Fshi kontaktin"</string>
    <string name="menu_dial" msgid="3223106222819685808">"Telefono kontaktin"</string>
    <string name="get_pin2" msgid="8204677063922225311">"Shkruaj PIN2-shin"</string>
    <string name="name" msgid="7329028332786872378">"Emri"</string>
    <string name="number" msgid="7905950798349903858">"Numri"</string>
    <string name="save" msgid="4094274636321939086">"Ruaj"</string>
    <string name="add_fdn_contact" msgid="2481915899633353976">"Shto numrin me telefonim të përzgjedhur"</string>
    <string name="adding_fdn_contact" msgid="7627379633721940991">"Po shton numrin me telefonim të përzgjedhur..."</string>
    <string name="fdn_contact_added" msgid="7458335758501736665">"Numri me telefonim të përzgjedhur u shtua."</string>
    <string name="edit_fdn_contact" msgid="7976936035587081480">"Redakto numrin me telefonim të përzgjedhur"</string>
    <string name="updating_fdn_contact" msgid="8370929876849803600">"Po përditëson numrin me telefonim të përzgjedhur..."</string>
    <string name="fdn_contact_updated" msgid="5497828782609005017">"Numri me telefonim të përzgjedhur u përditësua."</string>
    <string name="delete_fdn_contact" msgid="6668958073074151717">"Fshi numrin me telefonim të përzgjedhur"</string>
    <string name="deleting_fdn_contact" msgid="5669163206349319969">"Po fshin numrin me telefonim të përzgjedhur..."</string>
    <string name="fdn_contact_deleted" msgid="7154162327112259569">"Numri me telefonim të përzgjedhur u fshi."</string>
    <string name="pin2_invalid" msgid="5470854099230755944">"FDN-ja nuk u përditësua sepse shkrove një PIN të pasaktë."</string>
    <string name="fdn_invalid_number" msgid="8602417141715473998">"Funksioni FDN nuk u përditësua sepse numri është bosh ose i kalon 20 shifra."</string>
    <string name="pin2_or_fdn_invalid" msgid="6025144083384701197">"FDN-ja nuk u përditësua. PIN2-shi ishte i pasaktë ose numri i telefonit u refuzua."</string>
    <string name="fdn_failed" msgid="540018079008319747">"Operacioni FDN dështoi"</string>
    <string name="simContacts_emptyLoading" msgid="2203331234764498011">"Po lexon nga karta SIM..."</string>
    <string name="simContacts_empty" msgid="5270660846489561932">"S\'ka kontakte në kartën SIM."</string>
    <string name="simContacts_title" msgid="1861472842524839921">"Zgjidh kontaktet për importim"</string>
    <string name="simContacts_airplaneMode" msgid="5254946758982621072">"Çaktivizo modalitetin e aeroplanit për të importuar kontaktet nga karta SIM."</string>
    <string name="enable_pin" msgid="5422767284133234860">"Aktivizo/çaktivizo PIN-in e kartës SIM"</string>
    <string name="change_pin" msgid="9174186126330785343">"Ndrysho PIN-in e kartës SIM"</string>
    <string name="enter_pin_text" msgid="8532615714751931951">"PIN-i i kartës SIM:"</string>
    <string name="oldPinLabel" msgid="5287773661246368314">"PIN-i i vjetër"</string>
    <string name="newPinLabel" msgid="207488227285336897">"PIN i ri"</string>
    <string name="confirmPinLabel" msgid="257597715098070206">"Konfirmo PIN-in e ri"</string>
    <string name="badPin" msgid="8955102849303984935">"PIN-i i vjetër që ke shkruar nuk është i saktë. Provo sërish."</string>
    <string name="mismatchPin" msgid="5923253370683071889">"Kodet PIN që shkrove nuk përputhen. Provo sërish."</string>
    <string name="invalidPin" msgid="5981171102258684792">"Shkruaj një PIN që është 4 deri në 8 numra."</string>
    <string name="disable_sim_pin" msgid="3419351358300716472">"Pastro PIN-in e kartës SIM"</string>
    <string name="enable_sim_pin" msgid="4845145659651484248">"Vendos PIN-in e kartës SIM"</string>
    <string name="enable_in_progress" msgid="3417917024688497010">"Po vendos PIN-in…"</string>
    <string name="enable_pin_ok" msgid="2918545971413270063">"Vendosja e PIN-it"</string>
    <string name="disable_pin_ok" msgid="2109571368635883688">"PIN-i u fshi"</string>
    <string name="pin_failed" msgid="5644377896213584760">"PIN-i është i pasaktë"</string>
    <string name="pin_changed" msgid="4455736268023261662">"PIN-i u përditësua"</string>
    <string name="puk_requested" msgid="5921393215789090200">"Fjalëkalimi është i pasaktë. PIN-i tani është i bllokuar. Kërkohet PUK-u."</string>
    <string name="enter_pin2_text" msgid="8339444124477720345">"PIN2-shi"</string>
    <string name="oldPin2Label" msgid="8559146795026261502">"PIN2-shi i vjetër"</string>
    <string name="newPin2Label" msgid="4573956902204349054">"PIN2-shi i ri"</string>
    <string name="confirmPin2Label" msgid="8100319484454787708">"Konfirmo PIN2-shin e ri"</string>
    <string name="badPuk2" msgid="7910064009531541708">"PUK2-shi është i pasaktë. Provo sërish."</string>
    <string name="badPin2" msgid="6646896629970023109">"PIN2-shi i vjetër është i pasaktë. Provo sërish."</string>
    <string name="mismatchPin2" msgid="4177967478551851117">"Kodet PIN2 nuk përputhen. Provo sërish."</string>
    <string name="invalidPin2" msgid="1757045131429105595">"Fut një kod PIN2 që është 4 deri në 8 numra."</string>
    <string name="invalidPuk2" msgid="7059081153334815973">"Fut një kod PUK2 që është 8 numra."</string>
    <string name="pin2_changed" msgid="3724522579945610956">"PIN2-shi u përditësua"</string>
    <string name="label_puk2_code" msgid="4688069961795341948">"Fut kodin PUK2"</string>
    <string name="fdn_enable_puk2_requested" msgid="4991074891459554705">"Fjalëkalimi ishte i pasaktë. PIN2-shi është i bllokuar. Për të provuar sërish, ndrysho PIN2-shin."</string>
    <string name="puk2_requested" msgid="5831015200030161434">"Fjalëkalimi është i pasaktë. Karta SIM tani është e kyçur. Fut PUK2-shin."</string>
    <string name="puk2_blocked" msgid="3150263853077280049">"PUK2-shi është i bllokuar përgjithmonë."</string>
    <string name="pin2_attempts" msgid="720736232885011507">\n"Të kanë mbetur edhe <xliff:g id="NUMBER">%d</xliff:g> përpjekje."</string>
    <string name="pin2_unblocked" msgid="7791600368153469078">"PIN2-shi nuk është më i bllokuar"</string>
    <string name="pin2_error_exception" msgid="1088689322248996699">"Gabim në rrjet ose në kartën SIM"</string>
    <string name="doneButton" msgid="2859593360997984240">"U krye!"</string>
    <string name="voicemail_settings_number_label" msgid="8524164258691887790">"Numri i postës zanore"</string>
    <string name="card_title_dialing" msgid="5769417478498348054">"Po telefonon"</string>
    <string name="card_title_redialing" msgid="8253487008234167266">"Po riformon numrin"</string>
    <string name="card_title_conf_call" msgid="1162980346189744501">"Telefonatë konference"</string>
    <string name="card_title_incoming_call" msgid="7364539451234646909">"Telefonatë hyrëse"</string>
    <string name="card_title_call_ended" msgid="5544730338889702298">"Telefonata përfundoi"</string>
    <string name="card_title_on_hold" msgid="821463117892339942">"Në pritje"</string>
    <string name="card_title_hanging_up" msgid="3999101620995182450">"Mbyllja"</string>
    <string name="card_title_in_call" msgid="6346543933068225205">"Në telefonatë"</string>
    <string name="notification_voicemail_title" msgid="8933468752045550523">"Postë e re zanore"</string>
    <string name="notification_voicemail_title_count" msgid="4366360747660929916">"Postë e re zanore (<xliff:g id="COUNT">%d</xliff:g>)"</string>
    <string name="notification_voicemail_text_format" msgid="4447323569453981685">"Formo numrin <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
    <string name="notification_voicemail_no_vm_number" msgid="760963466895609716">"Numri i postës zanore është i panjohur"</string>
    <string name="notification_network_selection_title" msgid="4224455487793492772">"Nuk ka shërbim"</string>
    <string name="notification_network_selection_text" msgid="2607085729661923269">"Rrjeti i përzgjedhur (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nuk mundësohet"</string>
    <string name="incall_error_power_off" product="watch" msgid="2007450435656211658">"Aktivizo rrjetin celular, çaktivizo modalitetin e aeroplanit ose modalitetin e kursyesit të baterisë për të bërë një telefonatë."</string>
    <string name="incall_error_power_off" product="default" msgid="2947938060513306698">"Çaktivizo modalitetin e aeroplanit për të bërë telefonata."</string>
    <string name="incall_error_power_off_wfc" msgid="8711428920632416575">"Çaktivizo modalitetin e aeroplanit ose lidhu me ndonjë rrjet interneti valor për të bërë telefonata."</string>
    <string name="incall_error_ecm_emergency_only" msgid="738708660612388692">"Dil nga modaliteti i kthimit të telefonatës së urgjencës për të bërë një telefonatë jo urgjente."</string>
    <string name="incall_error_emergency_only" msgid="4678640422710818317">"I paregjistruar në rrjet."</string>
    <string name="incall_error_out_of_service" msgid="8587993036435080418">"Rrjeti celular nuk mundësohet."</string>
    <string name="incall_error_out_of_service_wfc" msgid="8741629779555132471">"Rrjeti celular nuk ofrohet. Lidhu me një rrjet pa tel për të bërë një telefonatë."</string>
    <string name="incall_error_no_phone_number_supplied" msgid="1150414018684246528">"Për të kryer një telefonatë, fut një numër të vlefshëm."</string>
    <string name="incall_error_call_failed" msgid="5891978320269774095">"Thirrja dështoi."</string>
    <string name="incall_error_cannot_add_call" msgid="8878159278947023326">"Telefonata nuk mund të shtohet në këtë moment. Mund të provosh të kontaktosh duke dërguar një mesazh."</string>
    <string name="incall_error_supp_service_unknown" msgid="655570339115407698">"Shërbimi nuk mbështetet"</string>
    <string name="incall_error_supp_service_switch" msgid="5237002176899962862">"Nuk mund të ndryshojë telefonatat."</string>
    <string name="incall_error_supp_service_separate" msgid="7224393405134545246">"Nuk mund të ndajë telefonatën."</string>
    <string name="incall_error_supp_service_transfer" msgid="7235952238189391438">"Nuk mund të transferojë."</string>
    <string name="incall_error_supp_service_conference" msgid="2505727299596357312">"Nuk mund të kryejë telefonatë konference."</string>
    <string name="incall_error_supp_service_reject" msgid="8998568661508655638">"Nuk mund të refuzojë telefonatën."</string>
    <string name="incall_error_supp_service_hangup" msgid="7434513517153834426">"Nuk mund të lëshojë telefonatën(at)."</string>
    <string name="incall_error_supp_service_hold" msgid="7967020511232222078">"Telefonatat nuk mund të mbahen në pritje."</string>
    <string name="incall_error_wfc_only_no_wireless_network" msgid="1782466780452640089">"Lidhu me një rrjet me valë për të bërë një telefonatë."</string>
    <string name="incall_error_promote_wfc" msgid="106510757624022064">"Aktivizo telefonatat nëpërmjet rrjetit Wi-Fi për të bërë një telefonatë."</string>
    <string name="emergency_enable_radio_dialog_title" msgid="4627849966634578257">"Telefonata e urgjencës"</string>
    <string name="emergency_enable_radio_dialog_message" msgid="207613549344420291">"Po aktivizon radion…"</string>
    <string name="emergency_enable_radio_dialog_retry" msgid="5960061579996526883">"Nuk ka shërbim. Po provon sërish…"</string>
    <string name="radio_off_during_emergency_call" msgid="2535800034010306830">"Nuk mund të hysh në modalitetin e aeroplanit gjatë telefonatave të urgjencës."</string>
    <string name="dial_emergency_error" msgid="1509085166367420355">"Nuk mund të telefonohet. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nuk është numër urgjence."</string>
    <string name="dial_emergency_empty_error" msgid="9130194953830414638">"Nuk mund të telefonohet. Formo një numër urgjence."</string>
    <string name="dialerKeyboardHintText" msgid="9192914825413747792">"Përdor tastierën për të formuar numrin"</string>
    <string name="onscreenHoldText" msgid="2285258239691145872">"Në pritje"</string>
    <string name="onscreenEndCallText" msgid="4403855834875398585">"Përfundo"</string>
    <string name="onscreenShowDialpadText" msgid="8561805492659639893">"Blloku i formimit të numrit"</string>
    <string name="onscreenMuteText" msgid="5011369181754261374">"Kalo në heshtje"</string>
    <string name="onscreenAddCallText" msgid="5140385634712287403">"Shto telefonatë"</string>
    <string name="onscreenMergeCallsText" msgid="6640195098064538950">"Shkri telefonatat"</string>
    <string name="onscreenSwapCallsText" msgid="1602990689244030047">"Shkëmbe"</string>
    <string name="onscreenManageCallsText" msgid="5473231160123254154">"Menaxho telefonatat"</string>
    <string name="onscreenManageConferenceText" msgid="6485935856534311346">"Menaxho konferencën"</string>
    <string name="onscreenAudioText" msgid="1710087112800041743">"Audio"</string>
    <string name="onscreenVideoCallText" msgid="4800924186056115442">"Telefonatë me video"</string>
    <string name="importSimEntry" msgid="6614358325359736031">"Importo"</string>
    <string name="importAllSimEntries" msgid="1503181169636198673">"Importoji të gjitha"</string>
    <string name="importingSimContacts" msgid="7374056215462575769">"Po importon kontaktet e kartës SIM"</string>
    <string name="importToFDNfromContacts" msgid="2130620207013368580">"Importo nga kontaktet"</string>
    <string name="singleContactImportedMsg" msgid="6868483416182599206">"Kontakti u importua"</string>
    <string name="failedToImportSingleContactMsg" msgid="415399285420353917">"Dështoi në importimin e kontaktit"</string>
    <string name="hac_mode_title" msgid="8740268574688743289">"Aparatet e dëgjimit"</string>
    <string name="hac_mode_summary" msgid="6833851160514929341">"Aktivizo përputhshmërinë e aparateve të dëgjimit"</string>
  <string-array name="tty_mode_entries">
    <item msgid="512950011423868021">"TTY i çaktivizuar"</item>
    <item msgid="3971695875449640648">"TTY i plotë"</item>
    <item msgid="1937509904407445684">"TTY HCO"</item>
    <item msgid="5644925873488772224">"TTY VCO"</item>
  </string-array>
    <string name="dtmf_tones_title" msgid="5163153771291340803">"Tonet DTMF"</string>
    <string name="dtmf_tones_summary" msgid="3351820372864020331">"Cakto gjatësinë e toneve DTMF"</string>
  <string-array name="dtmf_tone_entries">
    <item msgid="899650777817315681">"Normal"</item>
    <item msgid="2883365539347850535">"I gjatë"</item>
  </string-array>
    <string name="network_info_message" msgid="7738596060242881930">"Mesazh rrjeti"</string>
    <string name="network_error_message" msgid="3394780436230411413">"Mesazh gabimi"</string>
    <string name="ota_title_activate" msgid="8616918561356194398">"Aktivizo telefonin"</string>
    <string name="ota_touch_activate" msgid="6553212803262586244">"Nevojitet një telefonatë e veçantë për të aktivizuar shërbimin e telefonit. \n\nPasi të shtypësh “Aktivizo”, dëgjo udhëzimet e dhëna për të aktivizuar telefonin."</string>
    <string name="ota_hfa_activation_title" msgid="2234246934160473981">"Po aktivizon..."</string>
    <string name="ota_hfa_activation_dialog_message" msgid="8092479227918463415">"Telefoni po aktivizon shërbimin e të dhënave celulare.\n\nKjo mund të zgjasë deri në 5 minuta."</string>
    <string name="ota_skip_activation_dialog_title" msgid="2943366608272261306">"Të kapërcehet aktivizimi?"</string>
    <string name="ota_skip_activation_dialog_message" msgid="2440770373498870550">"Nëse anashkalon aktivizimin, nuk mund të kryesh telefonata ose të lidhesh me rrjetet e të dhënave celulare (megjithatë mund të lidhesh me rrjetet Wi-Fi). Derisa të aktivizosh telefonin, do të të kërkohet ta aktivizosh çdo herë që e ndez."</string>
    <string name="ota_skip_activation_dialog_skip_label" msgid="3458532775091563208">"Kapërce"</string>
    <string name="ota_activate" msgid="1368528132525626264">"Aktivizo"</string>
    <string name="ota_title_activate_success" msgid="6570240212263372046">"Telefoni është i aktivizuar."</string>
    <string name="ota_title_problem_with_activation" msgid="7095824491970084367">"Ka problem me aktivizimin"</string>
    <string name="ota_listen" msgid="162923839877584937">"Ndiq udhëzimet e folura derisa të dëgjosh që aktivizimi ka përfunduar."</string>
    <string name="ota_speaker" msgid="6904589278542719647">"Altoparlant"</string>
    <string name="ota_progress" msgid="460876637828044519">"Po programon telefonin…"</string>
    <string name="ota_failure" msgid="7713756181204620397">"Nuk mundi të programonte telefonin"</string>
    <string name="ota_successful" msgid="1880780692887077407">"Telefoni yt tani është i aktivizuar. Mund të zgjasë deri në 15 minuta derisa të fillojë shërbimi."</string>
    <string name="ota_unsuccessful" msgid="8072141612635635357">"Telefoni nuk u aktivizua. \nMund të nevojitet të gjesh një zonë me mbulim më të mirë (afër një dritareje ose jashtë). \n\nProvo sërish ose telefono shërbimin e klientit për më shumë opsione."</string>
    <string name="ota_spc_failure" msgid="3909983542575030796">"DËSHTIME TË SHUMTA SPC"</string>
    <string name="ota_call_end" msgid="4537279738134612388">"Prapa"</string>
    <string name="ota_try_again" msgid="7685477206465902290">"Provo sërish"</string>
    <string name="ota_next" msgid="3904945374358235910">"Përpara"</string>
    <string name="ecm_exit_dialog" msgid="4448531867763097533">"EcmExitDialog"</string>
    <string name="phone_entered_ecm_text" msgid="6266424252578731203">"Hyri në modalitetin e \"Kthimit të telefonatës së urgjencës\""</string>
    <string name="phone_in_ecm_notification_title" msgid="3226896828951687085">"Modaliteti i \"Kthimit të telefonatës së urgjencës\""</string>
    <string name="phone_in_ecm_call_notification_text" msgid="4611608947314729773">"Lidhja me të dhënat është çaktivizuar"</string>
    <string name="phone_in_ecm_notification_complete_time" msgid="7730376844178948351">"Nuk ka lidhje të të dhënave deri në <xliff:g id="COMPLETETIME">%s</xliff:g>"</string>
    <plurals name="alert_dialog_exit_ecm" formatted="false" msgid="7179911675595441201">
      <item quantity="other">Telefoni do të përdoret në modalitetin e \"Kthimit të Telefonatës së Urgjencës\" për <xliff:g id="COUNT_1">%s</xliff:g> minuta. Ndërkohë që është në këtë modalitet, nuk mund të përdoret asnjë aplikacion duke përdorur lidhje të dhënash. Dëshiron të dalësh tani?</item>
      <item quantity="one">Telefoni do të jetë në modalitetin e \"Kthimit të telefonatës së urgjencës\" për <xliff:g id="COUNT_0">%s</xliff:g> minuta. Ndërkohë që është në këtë modalitet, nuk mund të përdoret asnjë aplikacion duke përdorur lidhje të dhënash. Dëshiron të dalësh tani?</item>
    </plurals>
    <plurals name="alert_dialog_not_avaialble_in_ecm" formatted="false" msgid="8042973425225093895">
      <item quantity="other">Veprimi i përzgjedhur nuk mund të përdoret kur është në modalitetin e \"Kthimit të telefonatës së urgjencës\". Telefoni do të jetë në këtë modalitet për <xliff:g id="COUNT_1">%s</xliff:g> minuta. Dëshiron të dalësh tani?</item>
      <item quantity="one">Veprimi i përzgjedhur nuk mund të përdoret kur është në modalitetin e \"Kthimit të telefonatës së urgjencës\". Telefoni do të jetë në këtë modalitet për <xliff:g id="COUNT_0">%s</xliff:g> minuta. Dëshiron të dalësh tani?</item>
    </plurals>
    <string name="alert_dialog_in_ecm_call" msgid="1886723687211887104">"Veprimi i përzgjedhur nuk mund të përdoret gjatë një telefonate urgjente."</string>
    <string name="progress_dialog_exiting_ecm" msgid="4835734101617817074">"Modaliteti i \"Kthimit të telefonatës dalëse të urgjencës\""</string>
    <string name="alert_dialog_yes" msgid="6674268047820703974">"Po"</string>
    <string name="alert_dialog_no" msgid="1476091437797628703">"Jo"</string>
    <string name="alert_dialog_dismiss" msgid="2491494287075907171">"Injoro"</string>
    <string name="voicemail_provider" msgid="5135942703327136909">"Shërbimi"</string>
    <string name="voicemail_settings" msgid="72448049107749316">"Konfigurimi"</string>
    <string name="voicemail_number_not_set" msgid="6724904736891087856">"&lt;I pavendosur&gt;"</string>
    <string name="other_settings" msgid="3672912580359716394">"Cilësime të tjera të telefonatës"</string>
    <string name="calling_via_template" msgid="4839419581866928142">"Telefonatë përmes <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="contactPhoto" msgid="4713193418046639466">"fotografia e kontaktit"</string>
    <string name="goPrivate" msgid="865837794424530980">"bëje private"</string>
    <string name="selectContact" msgid="781975788478987237">"përzgjidh kontaktin"</string>
    <string name="not_voice_capable" msgid="2739898841461577811">"Telefonata zanore nuk mbështetet"</string>
    <string name="description_dial_button" msgid="7459705245418435351">"formo numrin"</string>
    <string name="voicemail_visual_voicemail_switch_title" msgid="5012622186976275457">"Posta zanore vizuale"</string>
    <string name="voicemail_set_pin_dialog_title" msgid="2797924461029093837">"Konfiguro kodin PIN"</string>
    <string name="voicemail_change_pin_dialog_title" msgid="6035421908626121564">"Ndrysho kodin PIN"</string>
    <string name="preference_category_ringtone" msgid="5197960752529332721">"Me zile dhe me dridhje"</string>
    <string name="pstn_connection_service_label" msgid="1743245930577325900">"Kartat e integruara SIM"</string>
    <string name="enable_video_calling_title" msgid="7237253660669000899">"Aktivizo telefonatën me video"</string>
    <string name="enable_video_calling_dialog_msg" msgid="8948186136957417948">"Për të aktivizuar telefonatën me video, nevojitet të aktivizosh \"Modalitetin e përparuar 4G LTE\" në cilësimet e rrjetit."</string>
    <string name="enable_video_calling_dialog_settings" msgid="576528473599603249">"Cilësimet e rrjetit"</string>
    <string name="enable_video_calling_dialog_close" msgid="7411471282167927991">"Mbyll"</string>
    <string name="sim_label_emergency_calls" msgid="4847699229529306397">"Telefonata urgjence"</string>
    <string name="sim_description_emergency_calls" msgid="7535215397212301562">"Vetëm telefonata urgjence"</string>
    <string name="sim_description_default" msgid="4778679519938775515">"Karta SIM, foleja: <xliff:g id="SLOT_ID">%s</xliff:g>"</string>
    <string name="accessibility_settings_activity_title" msgid="8562004288733103868">"Qasshmëria"</string>
    <string name="status_hint_label_incoming_wifi_call" msgid="5932176406432044638">"Telefonatë Wi-Fi nga"</string>
    <string name="status_hint_label_wifi_call" msgid="8900805254974653903">"Telefonatë me Wi-Fi"</string>
    <string name="emergency_action_launch_hint" msgid="4906759256275562674">"Trokit përsëri për ta hapur"</string>
    <string name="message_decode_error" msgid="3456481534066924855">"Ndodhi një gabim gjatë dekodimit të mesazhit."</string>
    <string name="callFailed_cdma_activation" msgid="2307989779233262164">"Një kartë SIM ka aktivizuar shërbimin tënd dhe ka përditësuar aftësitë e roaming-ut të telefonit tënd."</string>
    <string name="callFailed_cdma_call_limit" msgid="1556916577171457086">"Ka shumë thirrje aktive. Përfundo ose të bashko thirrjet ekzistuese para kryerjes së një thirrjeje të re."</string>
    <string name="callFailed_imei_not_accepted" msgid="132192626901238542">"Nuk mund të lidhet. Fut një kartë SIM të vlefshme."</string>
    <string name="callFailed_wifi_lost" msgid="5968076625137297184">"Lidhja Wi-Fi ka humbur. Telefonata u mbyll."</string>
    <string name="dialFailed_low_battery" msgid="8760548177088774268">"Telefonata me video nuk mund të kryhet për shkak të nivelit të ulët të baterisë."</string>
    <string name="callFailed_low_battery" msgid="4913582435905872616">"Telefonata me video u mbyll për shkak të nivelit të ulët të baterisë."</string>
    <string name="change_pin_title" msgid="7790232089699034029">"Ndrysho kodin PIN të postës zanore"</string>
    <string name="change_pin_continue_label" msgid="2135088662420163447">"Vazhdo"</string>
    <string name="change_pin_cancel_label" msgid="353535488390948596">"Anulo"</string>
    <string name="change_pin_ok_label" msgid="6204308560844889926">"Në rregull"</string>
    <string name="change_pin_enter_old_pin_header" msgid="419179847657548887">"Konfirmo kodin PIN të vjetër"</string>
    <string name="change_pin_enter_old_pin_hint" msgid="8579171678763615453">"Shkruaj kodin PIN të postës zanore për të vazhduar."</string>
    <string name="change_pin_enter_new_pin_header" msgid="2611191814590251532">"Cakto një kod të ri PIN."</string>
    <string name="change_pin_enter_new_pin_hint" msgid="2322940054329689309">"Kodi PIN duhet të ketë <xliff:g id="MIN">%1$d</xliff:g>-<xliff:g id="MAX">%2$d</xliff:g> shifra."</string>
    <string name="change_pin_confirm_pin_header" msgid="8113764019347322170">"Konfirmo kodin tënd PIN"</string>
    <string name="change_pin_confirm_pins_dont_match" msgid="4795052654904027909">"Kodet PIN nuk përputhen"</string>
    <string name="change_pin_succeeded" msgid="2022852286442211151">"Kodi PIN i postës zanore u përditësua"</string>
    <string name="change_pin_system_error" msgid="8308462387154257840">"Kodi PIN nuk u caktua"</string>
    <string name="mobile_data_status_roaming_turned_off_subtext" msgid="935636805765823307">"Roaming për të dhënat është çaktivizuar"</string>
    <string name="mobile_data_status_roaming_turned_on_subtext" msgid="1335176927083781041">"Roaming për të dhënat është aktivizuar"</string>
    <string name="mobile_data_status_roaming_without_plan_subtext" msgid="3568412513831673037">"Aktualisht në roaming, nevojitet plani i të dhënave"</string>
    <string name="mobile_data_status_roaming_with_plan_subtext" msgid="8721998948811064377">"Aktualisht në roaming, plani i të dhënave është aktiv"</string>
    <string name="mobile_data_status_no_plan_subtext" msgid="4887747337017565725">"Nuk ka të dhëna celulare të mbetura"</string>
    <string name="mobile_data_activate_prepaid" msgid="7447025165850512683">"Nuk ka të dhëna celulare të mbetura"</string>
    <string name="mobile_data_activate_prepaid_summary" msgid="5705389791791637666">"Shto të dhëna celulare nëpërmjet <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="mobile_data_activate_roaming_plan" msgid="5998161536947086264">"Nuk ka plan të roaming-ut"</string>
    <string name="mobile_data_activate_roaming_plan_summary" msgid="511202908883425459">"Shto një plan të roaming-ut nëpërmjet <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="mobile_data_activate_footer" msgid="5979019929980140594">"Mund të shtosh të dhëna celulare ose një plan të roaming-ut nëpërmjet operatorit tënd celular, <xliff:g id="PROVIDER_NAME">%s</xliff:g>."</string>
    <string name="mobile_data_activate_diag_title" msgid="9044252207707864493">"Të shtohen të dhëna?"</string>
    <string name="mobile_data_activate_diag_message" msgid="8216154678758451453">"Mund të duhet të shtosh të dhëna nëpërmjet <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
    <string name="mobile_data_activate_button" msgid="3682400969184405446">"SHTO TË DHËNA"</string>
    <string name="mobile_data_activate_cancel_button" msgid="1708022171547398765">"ANULO"</string>
</resources>
