<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/*
**
** Copyright 2015 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="wifi_fail_to_scan" msgid="1265540342578081461">"Nuk mund të skanojë për rrjete"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Asnjë"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"U ruajt"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Të çaktivizuara"</string>
    <string name="wifi_disabled_network_failure" msgid="2364951338436007124">"Dështim në konfigurimin e IP-së"</string>
    <string name="wifi_disabled_by_recommendation_provider" msgid="5168315140978066096">"Nuk është lidhur për shkak të rrjetit me cilësi të dobët"</string>
    <string name="wifi_disabled_wifi_failure" msgid="3081668066612876581">"Dështim i lidhjes WiFi"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Problem me vërtetimin"</string>
    <string name="wifi_cant_connect" msgid="5410016875644565884">"Nuk mund të lidhet"</string>
    <string name="wifi_cant_connect_to_ap" msgid="1222553274052685331">"Nuk mund të lidhet me \"<xliff:g id="AP_NAME">%1$s</xliff:g>\""</string>
    <string name="wifi_check_password_try_again" msgid="516958988102584767">"Kontrollo fjalëkalimin dhe provo sërish"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Nuk është brenda rrezes"</string>
    <string name="wifi_no_internet_no_reconnect" msgid="5724903347310541706">"Nuk do të lidhet automatikisht"</string>
    <string name="wifi_no_internet" msgid="4663834955626848401">"Nuk ka qasje në internet"</string>
    <string name="saved_network" msgid="4352716707126620811">"E ruajtur nga <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="connected_via_network_scorer" msgid="5713793306870815341">"Lidhur automatikisht përmes %1$s"</string>
    <string name="connected_via_network_scorer_default" msgid="7867260222020343104">"Lidhur automatikisht nëpërmjet ofruesit të vlerësimit të rrjetit"</string>
    <string name="connected_via_passpoint" msgid="2826205693803088747">"E lidhur përmes %1$s"</string>
    <string name="available_via_passpoint" msgid="1617440946846329613">"E mundshme përmes %1$s"</string>
    <string name="wifi_connected_no_internet" msgid="8202906332837777829">"U lidh, por nuk ka internet"</string>
    <string name="wifi_ap_unable_to_handle_new_sta" msgid="5348824313514404541">"Pika e qasjes është përkohësisht plot"</string>
    <string name="connected_via_carrier" msgid="7583780074526041912">"E lidhur përmes %1$s"</string>
    <string name="available_via_carrier" msgid="1469036129740799053">"E disponueshme përmes %1$s"</string>
    <string name="speed_label_very_slow" msgid="1867055264243608530">"Shumë e ulët"</string>
    <string name="speed_label_slow" msgid="813109590815810235">"E ngadaltë"</string>
    <string name="speed_label_okay" msgid="2331665440671174858">"Në rregull"</string>
    <string name="speed_label_medium" msgid="3175763313268941953">"Mesatare"</string>
    <string name="speed_label_fast" msgid="7715732164050975057">"E shpejtë"</string>
    <string name="speed_label_very_fast" msgid="2265363430784523409">"Shumë e shpejtë"</string>
    <string name="preference_summary_default_combination" msgid="8532964268242666060">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Shkëputur"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Po shkëputet..."</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Po lidhet..."</string>
    <string name="bluetooth_connected" msgid="5427152882755735944">"E lidhur<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Po çiftohet..."</string>
    <string name="bluetooth_connected_no_headset" msgid="616068069034994802">"E lidhur (pa telefon)<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="3736431800395923868">"E lidhur (pa media)<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_map" msgid="3200033913678466453">"E lidhur (nuk ka qasje te mesazhet)<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="2047403011284187056">"E lidhur (pa telefon ose media)<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_battery_level" msgid="5162924691231307748">"E lidhur, bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g><xliff:g id="ACTIVE_DEVICE">%2$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_headset_battery_level" msgid="1610296229139400266">"E lidhur (pa telefon), bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g><xliff:g id="ACTIVE_DEVICE">%2$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_a2dp_battery_level" msgid="3908466636369853652">"E lidhur (pa media), bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g><xliff:g id="ACTIVE_DEVICE">%2$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp_battery_level" msgid="1163440823807659316">"E lidhur (pa telefon ose media), bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g><xliff:g id="ACTIVE_DEVICE">%2$s</xliff:g>"</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Audioja e klipit \"media\""</string>
    <string name="bluetooth_profile_headset" msgid="7815495680863246034">"Telefonatat"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Transferimi i skedarëve"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Pajisja e hyrjes"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Qasja në internet"</string>
    <string name="bluetooth_profile_pbap" msgid="5372051906968576809">"Ndarja e kontakteve"</string>
    <string name="bluetooth_profile_pbap_summary" msgid="6605229608108852198">"Përdore për ndarjen e kontakteve"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Ndarja e lidhjes së internetit"</string>
    <string name="bluetooth_profile_map" msgid="1019763341565580450">"Mesazhet me tekst"</string>
    <string name="bluetooth_profile_sap" msgid="5764222021851283125">"Qasje në kartën SIM"</string>
    <string name="bluetooth_profile_a2dp_high_quality" msgid="5444517801472820055">"Audio HD: <xliff:g id="CODEC_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_profile_a2dp_high_quality_unknown_codec" msgid="8510588052415438887">"Audio HD"</string>
    <string name="bluetooth_profile_hearing_aid" msgid="7999237886427812595">"Aparati i dëgjimit"</string>
    <string name="bluetooth_hearing_aid_profile_summary_connected" msgid="7188282786730266159">"Lidhur me aparatin e dëgjimit"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"U lidh me audion e medias"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"U lidh me audion e telefonit"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"U lidh me serverin e transferimit të skedarëve"</string>
    <string name="bluetooth_map_profile_summary_connected" msgid="8191407438851351713">"U lidh me hartën"</string>
    <string name="bluetooth_sap_profile_summary_connected" msgid="8561765057453083838">"Lidhur me SAP"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Nuk u lidh me serverin e transferimit të skedarëve"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"U lidh me pajisjen e hyrjes"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Lidhur me pajisjen për qasje në internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"Po ndan lidhjen lokale të internetit me pajisjen"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5736111170225304239">"Përdor për qasje në internet"</string>
    <string name="bluetooth_map_profile_summary_use_for" msgid="5154200119919927434">"Përdore për hartën"</string>
    <string name="bluetooth_sap_profile_summary_use_for" msgid="7085362712786907993">"Përdor për qasje në kartën SIM"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Përdor për audion e medias"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Përdor për audion e telefonit"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Përdor për transferimin e skedarëve"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Përdore për hyrjen"</string>
    <string name="bluetooth_hearing_aid_profile_summary_use_for" msgid="908775281788309484">"Përdore për aparatin e dëgjimit"</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Çifto"</string>
    <string name="bluetooth_pairing_accept_all_caps" msgid="6061699265220789149">"ÇIFTO"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Anulo"</string>
    <string name="bluetooth_pairing_will_share_phonebook" msgid="4982239145676394429">"Çiftimi lejon qasjen te kontaktet dhe historiku yt i telefonatave."</string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Nuk mundi të çiftohej me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Nuk mundi të çiftohej me <xliff:g id="DEVICE_NAME">%1$s</xliff:g> për shkak të një kodi PIN ose një kodi të pasaktë."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Nuk mund të komunikohet me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Çiftimi u refuzua nga <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_talkback_computer" msgid="4875089335641234463">"Kompjuteri"</string>
    <string name="bluetooth_talkback_headset" msgid="5140152177885220949">"Kufjet me mikrofon"</string>
    <string name="bluetooth_talkback_phone" msgid="4260255181240622896">"Telefon"</string>
    <string name="bluetooth_talkback_imaging" msgid="551146170554589119">"Imazhe"</string>
    <string name="bluetooth_talkback_headphone" msgid="26580326066627664">"Kufje"</string>
    <string name="bluetooth_talkback_input_peripheral" msgid="5165842622743212268">"Hyrje periferike"</string>
    <string name="bluetooth_talkback_bluetooth" msgid="5615463912185280812">"Bluetooth-i"</string>
    <string name="accessibility_wifi_off" msgid="1166761729660614716">"Wi-Fi është çaktivizuar."</string>
    <string name="accessibility_no_wifi" msgid="8834610636137374508">"Wi-Fi është i shkëputur."</string>
    <string name="accessibility_wifi_one_bar" msgid="4869376278894301820">"Wi-Fi ka një vijë."</string>
    <string name="accessibility_wifi_two_bars" msgid="3569851234710034416">"Wi-Fi ka dy vija."</string>
    <string name="accessibility_wifi_three_bars" msgid="8134185644861380311">"Wi-Fi: tre vija."</string>
    <string name="accessibility_wifi_signal_full" msgid="7061045677694702">"Wi-Fi ka sinjal të plotë."</string>
    <string name="accessibility_wifi_security_type_none" msgid="1223747559986205423">"Rrjet i hapur"</string>
    <string name="accessibility_wifi_security_type_secured" msgid="862921720418885331">"Rrjet i sigurt"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Sistemi operativ Android"</string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Aplikacionet e hequra"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Aplikacionet dhe përdoruesit e hequr"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Ndarje përmes USB-së"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Zona e qasjes e lëvizshme"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Ndarja e internetit"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Zonë qasjeje dhe ndarjeje interneti"</string>
    <string name="managed_user_title" msgid="8109605045406748842">"Të gjitha aplikacionet e punës"</string>
    <string name="user_guest" msgid="8475274842845401871">"I ftuar"</string>
    <string name="unknown" msgid="1592123443519355854">"I panjohur"</string>
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Përdoruesi: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="launch_defaults_some" msgid="313159469856372621">"Disa caktime me parazgjedhje"</string>
    <string name="launch_defaults_none" msgid="4241129108140034876">"Nuk janë caktuar parazgjedhje"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Cilësimet \"tekst-në-ligjërim\""</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Dalja \"tekst-në-ligjërim\""</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Shpejtësia e të folurit"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Shpejtësia me të cilën thuhet teksti"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Tonaliteti"</string>
    <string name="tts_default_pitch_summary" msgid="1944885882882650009">"Ndikon te toni i ligjërimit të sintetizuar"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Gjuha"</string>
    <string name="tts_lang_use_system" msgid="2679252467416513208">"Përdor gjuhën e sistemit"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Nuk është përzgjedhur gjuha"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Cakton zërin specifik të gjuhës për tekstin e folur"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Dëgjo një shembull"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Luaj një demonstrim të shkurtër të sintezës së të folurit"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Instalo të dhënat e zërit"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Instalo të dhënat e zërit që kërkohen për sintezën e të folurit"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Ky motor i sintezës së të folurit mund të mbledhë të gjithë tekstin që do të flitet, duke përfshirë të dhëna personale si fjalëkalime dhe numra kartash krediti. Ai vjen nga motori <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Të aktivizohet përdorimi i këtij motori të sintezës së të folurit?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"Kjo gjuhë kërkon një lidhje funksionale interneti për daljen \"tekst-në-ligjërim\"."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"Ky është një shembull i sintezës së të folurit"</string>
    <string name="tts_status_title" msgid="7268566550242584413">"Statusi i gjuhës së parazgjedhur"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"<xliff:g id="LOCALE">%1$s</xliff:g> mbështetet plotësisht"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"<xliff:g id="LOCALE">%1$s</xliff:g> kërkon lidhje interneti"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"<xliff:g id="LOCALE">%1$s</xliff:g> nuk mbështetet"</string>
    <string name="tts_status_checking" msgid="5339150797940483592">"Po kontrollon..."</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Cilësimet për \"<xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>\""</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Hap cilësimet e motorit"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Motori i preferuar"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Të përgjithshme"</string>
    <string name="tts_reset_speech_pitch_title" msgid="5789394019544785915">"Rivendose tonin e të folurit."</string>
    <string name="tts_reset_speech_pitch_summary" msgid="8700539616245004418">"Rivendose te parazgjedhja tonin e të folurit për tekstin."</string>
  <string-array name="tts_rate_entries">
    <item msgid="6695494874362656215">"Shumë e ulët"</item>
    <item msgid="4795095314303559268">"E ngadaltë"</item>
    <item msgid="8903157781070679765">"Normale"</item>
    <item msgid="164347302621392996">"E shpejtë"</item>
    <item msgid="5794028588101562009">"Më e shpejtë"</item>
    <item msgid="7163942783888652942">"Shumë e shpejtë"</item>
    <item msgid="7831712693748700507">"E shpejtë"</item>
    <item msgid="5194774745031751806">"Shumë e shpejtë"</item>
    <item msgid="9085102246155045744">"Më e shpejta"</item>
  </string-array>
    <string name="choose_profile" msgid="6921016979430278661">"Zgjidh profilin"</string>
    <string name="category_personal" msgid="1299663247844969448">"Personale"</string>
    <string name="category_work" msgid="8699184680584175622">"Punë"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Opsionet e zhvilluesit"</string>
    <string name="development_settings_enable" msgid="542530994778109538">"Aktivizo opsionet e zhvilluesit"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Cakto opsionet për zhvillimin e aplikacionit"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Opsionet e programuesit nuk mundësohen për këtë përdorues"</string>
    <string name="vpn_settings_not_available" msgid="956841430176985598">"Cilësimet e VPN-së nuk ofrohen për këtë përdorues"</string>
    <string name="tethering_settings_not_available" msgid="6765770438438291012">"Cilësimet e ndarjes nuk ofrohen për këtë përdorues"</string>
    <string name="apn_settings_not_available" msgid="7873729032165324000">"Cilësimet e \"Emrit të pikës së qasjes\" nuk mund të përdoren për këtë përdorues"</string>
    <string name="enable_adb" msgid="7982306934419797485">"Korrigjimi i USB-së"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Korrigjo gabimet e modalitetit kur UBS-ja është e lidhur"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Anulo autorizimet e korrigjimeve të gabimeve të USB-së"</string>
    <string name="bugreport_in_power" msgid="7923901846375587241">"Shkurtorja e raportit të defektit në kod"</string>
    <string name="bugreport_in_power_summary" msgid="1778455732762984579">"Shfaq një buton në menynë e fikjes për marrjen e raportit të defekteve"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Qëndro zgjuar"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Ekrani nuk do të kalojë asnjëherë në gjendje gjumi gjatë ngarkimit"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Aktivizo regjistrin testues të Bluetooth HCI-së"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Kap të gjitha paketat HCI të Bluetooth-it në një skedar"</string>
    <string name="oem_unlock_enable" msgid="6040763321967327691">"Shkyçja e OEM-së"</string>
    <string name="oem_unlock_enable_summary" msgid="4720281828891618376">"Lejo shkyçjen e ngarkimit të sistemit"</string>
    <string name="confirm_enable_oem_unlock_title" msgid="4802157344812385674">"Të lejohet shkyçja e OEM-së?"</string>
    <string name="confirm_enable_oem_unlock_text" msgid="5517144575601647022">"PARALAJMËRIM! Funksionet e mbrojtjes së pajisjes nuk do të punojnë në këtë pajisje gjatë kohës që ky cilësim është i aktivizuar."</string>
    <string name="mock_location_app" msgid="7966220972812881854">"Zgjidh apl. që simulon vendndodhjen"</string>
    <string name="mock_location_app_not_set" msgid="809543285495344223">"Nuk është vendosur asnjë aplikacion që simulon vendndodhjen"</string>
    <string name="mock_location_app_set" msgid="8966420655295102685">"Aplikacioni për simulimin e vendndodhjes: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="debug_networking_category" msgid="7044075693643009662">"Rrjetet"</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Certifikimi i ekranit valor"</string>
    <string name="wifi_verbose_logging" msgid="4203729756047242344">"Aktivizo hyrjen Wi-Fi Verbose"</string>
    <string name="wifi_connected_mac_randomization" msgid="3168165236877957767">"Zgjedhja e rastësishme e MAC të lidhur"</string>
    <string name="mobile_data_always_on" msgid="8774857027458200434">"Të dhënat celulare gjithmonë aktive"</string>
    <string name="tethering_hardware_offload" msgid="7470077827090325814">"Përshpejtimi i harduerit për ndarjen"</string>
    <string name="bluetooth_show_devices_without_names" msgid="4708446092962060176">"Shfaq pajisjet me Bluetooth pa emra"</string>
    <string name="bluetooth_disable_absolute_volume" msgid="2660673801947898809">"Çaktivizo volumin absolut"</string>
    <string name="bluetooth_select_avrcp_version_string" msgid="3750059931120293633">"Versioni AVRCP i Bluetooth-it"</string>
    <string name="bluetooth_select_avrcp_version_dialog_title" msgid="7277329668298705702">"Zgjidh versionin AVRCP të Bluetooth-it"</string>
    <string name="bluetooth_select_a2dp_codec_type" msgid="90597356942154882">"Kodeku Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_type_dialog_title" msgid="4558347981670553665">"Zgjidh kodekun e audios së Bluetooth-it"</string>
    <string name="bluetooth_select_a2dp_codec_sample_rate" msgid="4788245703824623062">"Shpejtësia e shembullit të Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_sample_rate_dialog_title" msgid="5628790207448471613">"Zgjidh kodekun e audios së Bluetooth-it:\nShpejtësia e shembullit"</string>
    <string name="bluetooth_select_a2dp_codec_bits_per_sample" msgid="2099645202720164141">"Bite për shembull Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_bits_per_sample_dialog_title" msgid="4546131401358681321">"Zgjidh kodekun e audios së Bluetooth-it:\nBite për shembull"</string>
    <string name="bluetooth_select_a2dp_codec_channel_mode" msgid="884855779449390540">"Regjimi i kanalit Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_channel_mode_dialog_title" msgid="9133545781346216071">"Zgjidh kodekun e audios së Bluetooth-it:\nModaliteti i kanalit"</string>
    <string name="bluetooth_select_a2dp_codec_ldac_playback_quality" msgid="3619694372407843405">"Kodeku LDAC i audios së Bluetooth-it: Cilësia e luajtjes"</string>
    <string name="bluetooth_select_a2dp_codec_ldac_playback_quality_dialog_title" msgid="3181967377574368400">"Zgjidh kodekun LDAC të audios së Bluetooth-it:\nCilësia e luajtjes"</string>
    <string name="bluetooth_select_a2dp_codec_streaming_label" msgid="5347862512596240506">"Transmetimi: <xliff:g id="STREAMING_PARAMETER">%1$s</xliff:g>"</string>
    <string name="select_private_dns_configuration_title" msgid="3700456559305263922">"DNS-ja private"</string>
    <string name="select_private_dns_configuration_dialog_title" msgid="9221994415765826811">"Zgjidh modalitetin e DNS-së private"</string>
    <string name="private_dns_mode_off" msgid="8236575187318721684">"Joaktiv"</string>
    <!-- no translation found for private_dns_mode_opportunistic (8314986739896927399) -->
    <skip />
    <string name="private_dns_mode_provider" msgid="8354935160639360804">"Emri i pritësit të ofruesit të DNS-së private"</string>
    <string name="private_dns_mode_provider_hostname_hint" msgid="2487492386970928143">"Fut emrin e pritësit të ofruesit të DNS-së"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Shfaq opsionet për certifikimin e ekranit valor"</string>
    <string name="wifi_verbose_logging_summary" msgid="6615071616111731958">"Rrit nivelin regjistrues të Wi‑Fi duke shfaqur SSID RSSI-në te Zgjedhësi i Wi‑Fi"</string>
    <string name="wifi_connected_mac_randomization_summary" msgid="1743059848752201485">"Zgjidh rastësisht adresën MAC kur lidhesh me rrjete Wi‑Fi"</string>
    <string name="select_logd_size_title" msgid="7433137108348553508">"Madhësitë e regjistruesit"</string>
    <string name="select_logd_size_dialog_title" msgid="1206769310236476760">"Përzgjidh madhësitë e regjistruesit"</string>
    <string name="dev_logpersist_clear_warning_title" msgid="684806692440237967">"Do të pastrosh hapësirën ruajtëse të vazhdueshme të regjistruesit?"</string>
    <string name="dev_logpersist_clear_warning_message" msgid="2256582531342994562">"Kur nuk monitorojmë më me regjistruesin e vazhdueshëm, kërkohet që t\'i spastrojmë të dhënat e regjistruesit që qëndrojnë në pajisjen tënde."</string>
    <string name="select_logpersist_title" msgid="7530031344550073166">"Ruaj të dhënat e regjistruesit vazhdimisht në pajisje"</string>
    <string name="select_logpersist_dialog_title" msgid="4003400579973269060">"Zgjidh memoriet e regjistrit për të ruajtur vazhdimisht në pajisje"</string>
    <string name="select_usb_configuration_title" msgid="2649938511506971843">"Konfigurimi i USB-së"</string>
    <string name="select_usb_configuration_dialog_title" msgid="6385564442851599963">"Konfigurimi i USB-së"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Lejo vendndodhje të simuluara"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Lejo vendndodhje të simuluara"</string>
    <string name="debug_view_attributes" msgid="6485448367803310384">"Aktivizo shikimin e inspektimit të atributeve"</string>
    <string name="mobile_data_always_on_summary" msgid="8149773901431697910">"Mbaji të dhënat celulare gjithmonë aktive edhe kur Wi‑Fi është aktiv (për ndërrim të shpejtë të rrjetit)."</string>
    <string name="tethering_hardware_offload_summary" msgid="7726082075333346982">"Përdor përshpejtimin e harduerit për ndarjen nëse është i disponueshëm"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Të lejohet korrigjimi i USB-së?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Korrigjuesi i USB-së është vetëm për qëllime zhvillimore. Përdore për të kopjuar të dhëna mes kompjuterit dhe pajisjes tënde, për të instaluar aplikacione në pajisjen tënde pa asnjë njoftim si dhe për të lexuar të dhënat e ditarit."</string>
    <string name="adb_keys_warning_message" msgid="5659849457135841625">"Të bllokohet qasja për korrigjim të USB-së nga të gjithë kompjuterët që ke autorizuar më parë?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Të lejohen cilësimet e zhvillimit?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Këto cilësime janë të projektuara vetëm për përdorim në programim. Ato mund të shkaktojnë që pajisja dhe aplikacionet në të, të mos punojnë ose të veprojnë në mënyrë të gabuar."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Verifiko apl. përmes USB-së"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Kontrollo aplikacionet e instaluara nëpërmjet ADB/ADT për sjellje të dëmshme."</string>
    <string name="bluetooth_show_devices_without_names_summary" msgid="2351196058115755520">"Pajisjet me Bluetooth do të shfaqen pa emra (vetëm adresat MAC)"</string>
    <string name="bluetooth_disable_absolute_volume_summary" msgid="6031284410786545957">"Çaktivizon funksionin e volumit absolut të Bluetooth në rast të problemeve të volumit me pajisjet në largësi, si p.sh. një volum i lartë i papranueshëm ose mungesa e kontrollit."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Terminali lokal"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Aktivizo aplikacionin terminal që ofron qasje në guaskën lokale"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"Kontrolli HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Cakto kontrollin e HDCP-së"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Korrigjimi i gabimeve"</string>
    <string name="debug_app" msgid="8349591734751384446">"Zgjidh aplikacionin e korrigjimit"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Nuk është caktuar asnjë aplikacion korrigjimi"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Aplikacioni i korrigjimit: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Zgjidh aplikacionin"</string>
    <string name="no_application" msgid="2813387563129153880">"Asnjë"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Prit për korrigjuesin"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Aplikacioni i korrigjimit të gabimeve pret që korrigjuesi të bashkëngjitet para ekzekutimit"</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Hyrja"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Vizatime"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Interpretimi i përshpejtuar i harduerit"</string>
    <string name="media_category" msgid="4388305075496848353">"Media"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Monitorimi"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Aktivizo modalitetin e rreptë"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Ndriço ekranin kur aplikacionet kryejnë operacione të gjata teksa bashkëveprojnë"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Vendndodhja e treguesit"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Mbivendosja e ekranit tregon të dhënat e prekjes"</string>
    <string name="show_touches" msgid="2642976305235070316">"Shfaq trokitjet"</string>
    <string name="show_touches_summary" msgid="6101183132903926324">"Shfaq reagimet vizuale për trokitjet"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Shfaq përditësimet e sipërfaqes"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Ndriço të gjitha sipërfaqet e dritares kur ato të përditësohen"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Shfaq përditësimet e pamjes së GPU-së"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Ndriço pamjet brenda dritareve kur dizajnohen me GPU-në"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Shfaq përditësimet e shtresave të harduerit"</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Ndriço në të gjelbër shtresat e harduerit që përditësohen"</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Korrigjo konfliktet e GPU-së"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Çaktivizo mbishtresimin e HW-së"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Përdor gjithmonë GPU-në për përbërjen e ekranit"</string>
    <string name="simulate_color_space" msgid="6745847141353345872">"Simulo hapësirën e ngjyrës"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Aktivizo gjurmët e OpenGL-së"</string>
    <string name="usb_audio_disable_routing" msgid="8114498436003102671">"Çaktivizo rrugëzuezin e audios përmes USB-së"</string>
    <string name="usb_audio_disable_routing_summary" msgid="980282760277312264">"Çaktivizo rrugëzuesin automatik për te kufjet ose altoparlantët"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Shfaq konturet e kuadrit"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Shfaq konturet e klipit, hapësirat etj."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Detyro drejtimin e shkrimit nga e djathta në të majtë"</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Ndrysho me detyrim drejtimin e planit të ekranit nga e djathta në të majtë për të gjitha vendet"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Detyro interpretimin e GPU-së"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Detyro përdorimin e GPU-së për vizatimin e dytë"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Detyro 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Aktivizo 4x MSAA në aplikacionet OpenGL ES 2.0"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Korrigjo veprimet mbi klipet jodrejtkëndore"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Interpretimi i profilit të GPU-së"</string>
    <string name="enable_gpu_debug_layers" msgid="3848838293793255097">"Aktivizo shtresat e korrigjimit të GPU-së"</string>
    <string name="enable_gpu_debug_layers_summary" msgid="8009136940671194940">"Lejo ngarkimin e shtresave të korrigjimit të GPU-së për aplikacionet e korrigjimit"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Animacioni i dritares"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Animacioni kalimtar"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Kohëzgjatja e animatorit"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Simulo ekranet dytësore"</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Aplikacionet"</string>
    <string name="immediately_destroy_activities" msgid="1579659389568133959">"Mos i ruaj aktivitetet"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Fshi çdo aktivitet sapo të largohet përdoruesi"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Kufizimi i proceseve në sfond"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Shfaq raportet ANR"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Shfaq raportet ANR (Aplikacioni nuk përgjigjet) për aplikacionet në sfond"</string>
    <string name="show_notification_channel_warnings" msgid="1399948193466922683">"Shfaq paralajmërimet e kanalit të njoftimeve"</string>
    <string name="show_notification_channel_warnings_summary" msgid="5536803251863694895">"Shfaq paralajmërimin në ekran kur një aplikacion poston një njoftim pa një kanal të vlefshëm"</string>
    <string name="force_allow_on_external" msgid="3215759785081916381">"Detyro lejimin në hapësirën e jashtme"</string>
    <string name="force_allow_on_external_summary" msgid="3640752408258034689">"Bën që çdo aplikacion të jetë i përshtatshëm për t\'u shkruar në hapësirën ruajtëse të jashtme, pavarësisht nga vlerat e manifestit"</string>
    <string name="force_resizable_activities" msgid="8615764378147824985">"Detyro madhësinë e ndryshueshme për aktivitetet"</string>
    <string name="force_resizable_activities_summary" msgid="6667493494706124459">"Bëj që të gjitha aktivitetet të kenë madhësi të ndryshueshme për përdorimin me shumë dritare, pavarësisht vlerave të manifestit."</string>
    <string name="enable_freeform_support" msgid="1461893351278940416">"Aktivizo dritaret me formë të lirë"</string>
    <string name="enable_freeform_support_summary" msgid="8247310463288834487">"Aktivizo mbështetjen për dritaret eksperimentale me formë të lirë."</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Fjalëkalimi rezervë i kompjuterit"</string>
    <string name="local_backup_password_summary_none" msgid="6951095485537767956">"Rezervimet e plota në kompjuter nuk janë të mbrojtura aktualisht"</string>
    <string name="local_backup_password_summary_change" msgid="5376206246809190364">"Trokit për të ndryshuar ose hequr fjalëkalimin për rezervime të plota të desktopit"</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Fjalëkalimi i ri u vendos"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="7805892532752708288">"Fjalëkalimi i ri dhe konfirmimi nuk përputhen"</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Vendosja e fjalëkalimit dështoi"</string>
  <string-array name="color_mode_names">
    <item msgid="2425514299220523812">"Të gjalla (parazgjedhja)"</item>
    <item msgid="8446070607501413455">"Natyrale"</item>
    <item msgid="6553408765810699025">"Standarde"</item>
  </string-array>
  <string-array name="color_mode_descriptions">
    <item msgid="4979629397075120893">"Ngjyra të përmirësuara"</item>
    <item msgid="8280754435979370728">"Ngjyra natyrale siç shikohen me sy të lirë"</item>
    <item msgid="5363960654009010371">"Ngjyra të optimizuara për përmbajtjet dixhitale"</item>
  </string-array>
    <string name="inactive_apps_title" msgid="9042996804461901648">"Aplikacionet në gatishmëri"</string>
    <string name="inactive_app_inactive_summary" msgid="5091363706699855725">"Joaktiv. Trokit për ta ndryshuar."</string>
    <string name="inactive_app_active_summary" msgid="4174921824958516106">"Aktiv. Trokit për ta ndryshuar."</string>
    <string name="standby_bucket_summary" msgid="6567835350910684727">"Gjendja e gatishmërisë e aplikacionit:<xliff:g id="BUCKET"> %s</xliff:g>"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Shërbimet në ekzekutim"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Shiko dhe kontrollo shërbimet që po ekzekutohen aktualisht"</string>
    <string name="select_webview_provider_title" msgid="4628592979751918907">"Zbatimi i WebView"</string>
    <string name="select_webview_provider_dialog_title" msgid="4370551378720004872">"Cakto zbatimin e WebView"</string>
    <string name="select_webview_provider_toast_text" msgid="5466970498308266359">"Kjo zgjedhje nuk është më e vlefshme. Provo përsëri."</string>
    <string name="convert_to_file_encryption" msgid="3060156730651061223">"Konverto në enkriptimin e skedarit"</string>
    <string name="convert_to_file_encryption_enabled" msgid="2861258671151428346">"Konverto..."</string>
    <string name="convert_to_file_encryption_done" msgid="7859766358000523953">"Enkriptimi i skedarit është kryer tashmë"</string>
    <string name="title_convert_fbe" msgid="1263622876196444453">"Po konvertohet në enkriptimin e bazuar te skedari"</string>
    <string name="convert_to_fbe_warning" msgid="6139067817148865527">"Konverto ndarjen e të dhënave në enkriptimin e bazuar te skedari.\n !!Paralajmërim!! Kjo gjë do të spastrojë të gjitha të dhënat e tua.\n Ky funksion është alfa dhe mund të mos punojë si duhet.\n Shtyp \"Pastro dhe konverto...\" për të vazhduar."</string>
    <string name="button_convert_fbe" msgid="5152671181309826405">"Pastro dhe konverto..."</string>
    <string name="picture_color_mode" msgid="4560755008730283695">"Modalitti i ngjyrave të figurës"</string>
    <string name="picture_color_mode_desc" msgid="1141891467675548590">"Përdor sRGB"</string>
    <string name="daltonizer_mode_disabled" msgid="7482661936053801862">"Çaktivizuar"</string>
    <string name="daltonizer_mode_monochromacy" msgid="8485709880666106721">"Monokromaci"</string>
    <string name="daltonizer_mode_deuteranomaly" msgid="5475532989673586329">"Deuteranomali (e kuqe - e gjelbër)"</string>
    <string name="daltonizer_mode_protanomaly" msgid="8424148009038666065">"Protanomali (e kuqe - e gjelbër)"</string>
    <string name="daltonizer_mode_tritanomaly" msgid="481725854987912389">"Tritanomali (e kaltër - e verdhë)"</string>
    <string name="accessibility_display_daltonizer_preference_title" msgid="5800761362678707872">"Korrigjimi i ngjyrës"</string>
    <string name="accessibility_display_daltonizer_preference_subtitle" msgid="3484969015295282911">"Ky funksion është eksperimental dhe mund të ndikojë në veprimtari."</string>
    <string name="daltonizer_type_overridden" msgid="3116947244410245916">"Mbivendosur nga <xliff:g id="TITLE">%1$s</xliff:g>"</string>
    <string name="power_remaining_duration_only" msgid="845431008899029842">"Rreth <xliff:g id="TIME">%1$s</xliff:g> të mbetura"</string>
    <!-- no translation found for power_discharging_duration (6655472132189365839) -->
    <skip />
    <string name="power_remaining_duration_only_enhanced" msgid="5992456722677973678">"Rreth <xliff:g id="TIME">%1$s</xliff:g> të mbetura bazuar në përdorimin tënd"</string>
    <!-- no translation found for power_discharging_duration_enhanced (5726302316642148671) -->
    <skip />
    <string name="power_remaining_duration_only_short" msgid="5329694252258605547">"<xliff:g id="TIME">%1$s</xliff:g> të mbetura"</string>
    <!-- no translation found for power_discharge_by_enhanced (8788299408879961465) -->
    <skip />
    <!-- no translation found for power_discharge_by_only_enhanced (7692297898877104416) -->
    <skip />
    <!-- no translation found for power_discharge_by (6427074755635635749) -->
    <skip />
    <!-- no translation found for power_discharge_by_only (5888058889261108064) -->
    <skip />
    <string name="power_remaining_less_than_duration_only" msgid="5996752448813295329">"Më pak se <xliff:g id="THRESHOLD">%1$s</xliff:g> të mbetura"</string>
    <!-- no translation found for power_remaining_less_than_duration (5751885147712659423) -->
    <skip />
    <!-- no translation found for power_remaining_more_than_subtext (3176771815132876675) -->
    <skip />
    <!-- no translation found for power_remaining_only_more_than_subtext (8931654680569617380) -->
    <skip />
    <!-- no translation found for power_remaining_duration_only_shutdown_imminent (1181059207608751924) -->
    <skip />
    <!-- no translation found for power_remaining_duration_only_shutdown_imminent (2606370266981054691) -->
    <skip />
    <!-- no translation found for power_remaining_duration_only_shutdown_imminent (2918084807716859985) -->
    <skip />
    <!-- no translation found for power_remaining_duration_shutdown_imminent (3090926004324573908) -->
    <skip />
    <!-- no translation found for power_remaining_duration_shutdown_imminent (7466484148515796216) -->
    <skip />
    <!-- no translation found for power_remaining_duration_shutdown_imminent (603933521600231649) -->
    <skip />
    <string name="power_charging" msgid="1779532561355864267">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATE">%2$s</xliff:g>"</string>
    <string name="power_remaining_charging_duration_only" msgid="1421102457410268886">"<xliff:g id="TIME">%1$s</xliff:g> të mbetura deri në ngarkimin e plotë"</string>
    <string name="power_charging_duration" msgid="4676999980973411875">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="TIME">%2$s</xliff:g> derisa të mbushet plotësisht"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"I panjohur"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Po ngarkohet"</string>
    <string name="battery_info_status_charging_lower" msgid="8689770213898117994">"po ngarkohet"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Nuk po ngarkohet"</string>
    <string name="battery_info_status_not_charging" msgid="8523453668342598579">"Në prizë, por nuk mund të ngarkohet për momentin"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"E mbushur"</string>
    <string name="disabled_by_admin_summary_text" msgid="6750513964908334617">"Kontrolluar nga administratori"</string>
    <string name="enabled_by_admin" msgid="5302986023578399263">"Aktivizuar nga administratori"</string>
    <string name="disabled_by_admin" msgid="8505398946020816620">"Çaktivizuar nga administratori"</string>
    <string name="disabled" msgid="9206776641295849915">"Çaktivizuar"</string>
    <string name="external_source_trusted" msgid="2707996266575928037">"Lejohet"</string>
    <string name="external_source_untrusted" msgid="2677442511837596726">"Nuk lejohet"</string>
    <string name="install_other_apps" msgid="6986686991775883017">"Instalo aplikacione të panjohura"</string>
    <string name="home" msgid="3256884684164448244">"Kreu i cilësimeve"</string>
  <string-array name="battery_labels">
    <item msgid="8494684293649631252">"0%"</item>
    <item msgid="8934126114226089439">"50%"</item>
    <item msgid="1286113608943010849">"100%"</item>
  </string-array>
    <string name="charge_length_format" msgid="8978516217024434156">"<xliff:g id="ID_1">%1$s</xliff:g> më parë"</string>
    <string name="remaining_length_format" msgid="7886337596669190587">"<xliff:g id="ID_1">%1$s</xliff:g> të mbetura"</string>
    <string name="screen_zoom_summary_small" msgid="5867245310241621570">"I vogël"</string>
    <string name="screen_zoom_summary_default" msgid="2247006805614056507">"I parazgjedhur"</string>
    <string name="screen_zoom_summary_large" msgid="4835294730065424084">"I madh"</string>
    <string name="screen_zoom_summary_very_large" msgid="7108563375663670067">"Më i madh"</string>
    <string name="screen_zoom_summary_extremely_large" msgid="7427320168263276227">"Më i madhi"</string>
    <string name="screen_zoom_summary_custom" msgid="5611979864124160447">"I personalizuar (<xliff:g id="DENSITYDPI">%d</xliff:g>)"</string>
    <string name="help_feedback_label" msgid="6815040660801785649">"Ndihma dhe komentet"</string>
    <string name="content_description_menu_button" msgid="8182594799812351266">"Menyja"</string>
    <string name="retail_demo_reset_message" msgid="118771671364131297">"Fut fjalëkalimin për të kryer rivendosje në gjendje fabrike në modalitetin e demonstrimit"</string>
    <string name="retail_demo_reset_next" msgid="8356731459226304963">"Përpara"</string>
    <string name="retail_demo_reset_title" msgid="696589204029930100">"Kërkohet fjalëkalimi"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Metodat aktive të hyrjeve"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="5747329075020379587">"Përdor gjuhët e sistemit"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Dështoi në hapjen e cilësimeve për <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g>"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Kjo metodë hyrjeje mund të mbledhë të gjithë tekstin që shkruan, përfshirë të dhënat personale si fjalëkalimet dhe numrat e kartave të kreditit. Kjo vjen nga aplikacioni <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Të përdoret kjo metodë hyrjeje?"</string>
    <string name="direct_boot_unaware_dialog_message" msgid="7870273558547549125">"Shënim: Pas një rinisjeje, ky aplikacion nuk mund të niset derisa të shkyçësh telefonin"</string>
    <string name="ims_reg_title" msgid="7609782759207241443">"Gjendja e regjistrimit të IMS-së"</string>
    <string name="ims_reg_status_registered" msgid="933003316932739188">"Regjistruar"</string>
    <string name="ims_reg_status_not_registered" msgid="6529783773485229486">"Paregjistruar"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Nuk ofrohet"</string>
    <plurals name="wifi_tether_connected_summary" formatted="false" msgid="3871603864314407780">
      <item quantity="other">%1$d pajisje të lidhura</item>
      <item quantity="one">%1$d pajisje e lidhur</item>
    </plurals>
    <string name="accessibility_manual_zen_more_time" msgid="1636187409258564291">"Më shumë kohë."</string>
    <string name="accessibility_manual_zen_less_time" msgid="6590887204171164991">"Më pak kohë."</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Aktivizo"</string>
    <string name="cancel" msgid="6859253417269739139">"Anulo"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Aktivizo \"Mos shqetëso\""</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Asnjëherë"</string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Vetëm me prioritet"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_alarm_warning_indef" msgid="3007988140196673193">"Nuk do ta dëgjosh alarmin e radhës në <xliff:g id="WHEN">%1$s</xliff:g> nëse nuk e çaktivizon këtë përpara asaj ore"</string>
    <string name="zen_alarm_warning" msgid="6236690803924413088">"Nuk do ta dëgjosh alarmin e radhës në <xliff:g id="WHEN">%1$s</xliff:g>"</string>
    <string name="alarm_template" msgid="4996153414057676512">"në <xliff:g id="WHEN">%1$s</xliff:g>"</string>
    <string name="alarm_template_far" msgid="3779172822607461675">"ditën <xliff:g id="WHEN">%1$s</xliff:g>"</string>
</resources>
