<?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="2333336097603822490">"Nuk mund të skanojë për rrjete"</string>
    <string name="wifi_security_none" msgid="7392696451280611452">"Asnjë"</string>
    <string name="wifi_remembered" msgid="3266709779723179188">"U ruajt"</string>
    <string name="wifi_disconnected" msgid="7054450256284661757">"Shkëputur"</string>
    <string name="wifi_disabled_generic" msgid="2651916945380294607">"Të çaktivizuara"</string>
    <string name="wifi_disabled_network_failure" msgid="2660396183242399585">"Dështim në konfigurimin e IP-së"</string>
    <string name="wifi_disabled_by_recommendation_provider" msgid="1302938248432705534">"Nuk është lidhur për shkak të rrjetit me cilësi të dobët"</string>
    <string name="wifi_disabled_wifi_failure" msgid="8819554899148331100">"Dështim i lidhjes WiFi"</string>
    <string name="wifi_disabled_password_failure" msgid="6892387079613226738">"Problem me vërtetimin"</string>
    <string name="wifi_cant_connect" msgid="5718417542623056783">"Nuk mund të lidhet"</string>
    <string name="wifi_cant_connect_to_ap" msgid="3099667989279700135">"Nuk mund të lidhet me \"<xliff:g id="AP_NAME">%1$s</xliff:g>\""</string>
    <string name="wifi_check_password_try_again" msgid="8817789642851605628">"Kontrollo fjalëkalimin dhe provo sërish"</string>
    <string name="wifi_not_in_range" msgid="1541760821805777772">"Nuk është brenda rrezes"</string>
    <string name="wifi_no_internet_no_reconnect" msgid="821591791066497347">"Nuk do të lidhet automatikisht"</string>
    <string name="wifi_no_internet" msgid="1774198889176926299">"Nuk ka qasje në internet"</string>
    <string name="saved_network" msgid="7143698034077223645">"E ruajtur nga <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="connected_via_network_scorer" msgid="7665725527352893558">"Lidhur automatikisht përmes %1$s"</string>
    <string name="connected_via_network_scorer_default" msgid="7973529709744526285">"Lidhur automatikisht nëpërmjet ofruesit të vlerësimit të rrjetit"</string>
    <string name="connected_via_passpoint" msgid="7735442932429075684">"E lidhur përmes %1$s"</string>
    <string name="connected_via_app" msgid="3532267661404276584">"Lidhur përmes <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="available_via_passpoint" msgid="1716000261192603682">"E mundshme përmes %1$s"</string>
    <string name="tap_to_sign_up" msgid="5356397741063740395">"Trokit për t\'u regjistruar"</string>
    <string name="wifi_connected_no_internet" msgid="5087420713443350646">"Nuk ka internet"</string>
    <string name="private_dns_broken" msgid="1984159464346556931">"Serveri privat DNS nuk mund të qaset"</string>
    <string name="wifi_limited_connection" msgid="1184778285475204682">"Lidhje e kufizuar"</string>
    <string name="wifi_status_no_internet" msgid="3799933875988829048">"Nuk ka internet"</string>
    <string name="wifi_status_sign_in_required" msgid="2236267500459526855">"Kërkohet identifikimi"</string>
    <string name="wifi_ap_unable_to_handle_new_sta" msgid="5885145407184194503">"Pika e qasjes është përkohësisht plot"</string>
    <string name="connected_via_carrier" msgid="1968057009076191514">"E lidhur përmes %1$s"</string>
    <string name="available_via_carrier" msgid="465598683092718294">"E disponueshme përmes %1$s"</string>
    <string name="osu_opening_provider" msgid="4318105381295178285">"Po hapet <xliff:g id="PASSPOINTPROVIDER">%1$s</xliff:g>"</string>
    <string name="osu_connect_failed" msgid="9107873364807159193">"Nuk mund të lidhej"</string>
    <string name="osu_completing_sign_up" msgid="8412636665040390901">"Po përfundon regjistrimin…"</string>
    <string name="osu_sign_up_failed" msgid="5605453599586001793">"Regjistrimi nuk mund të përfundonte. Trokit për të provuar përsëri."</string>
    <string name="osu_sign_up_complete" msgid="7640183358878916847">"Regjistrimi përfundoi. Po lidhet…"</string>
    <string name="speed_label_very_slow" msgid="8526005255731597666">"Shumë e ulët"</string>
    <string name="speed_label_slow" msgid="6069917670665664161">"E ngadaltë"</string>
    <string name="speed_label_okay" msgid="1253594383880810424">"Në rregull"</string>
    <string name="speed_label_medium" msgid="9078405312828606976">"Mesatare"</string>
    <string name="speed_label_fast" msgid="2677719134596044051">"E shpejtë"</string>
    <string name="speed_label_very_fast" msgid="8215718029533182439">"Shumë e shpejtë"</string>
    <string name="wifi_passpoint_expired" msgid="6540867261754427561">"Skaduar"</string>
    <string name="preference_summary_default_combination" msgid="2644094566845577901">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="bluetooth_disconnected" msgid="7739366554710388701">"Shkëputur"</string>
    <string name="bluetooth_disconnecting" msgid="7638892134401574338">"Po shkëputet..."</string>
    <string name="bluetooth_connecting" msgid="5871702668260192755">"Po lidhet..."</string>
    <string name="bluetooth_connected" msgid="8065345572198502293">"E lidhur<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_pairing" msgid="4269046942588193600">"Po çiftohet..."</string>
    <string name="bluetooth_connected_no_headset" msgid="2224101138659967604">"E lidhur (pa telefon)<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="8566874395813947092">"E lidhur (pa media)<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_map" msgid="3381860077002724689">"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="2893204819854215433">"E lidhur (pa telefon ose media)<xliff:g id="ACTIVE_DEVICE">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_battery_level" msgid="5410325759372259950">"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="2661863370509206428">"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="6499078454894324287">"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="8477440576953067242">"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_active_battery_level" msgid="3450745316700494425">"Aktiv, bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="bluetooth_active_battery_level_untethered" msgid="2706188607604205362">"Aktiv, L: Bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE_0">%1$s</xliff:g>, R: Bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE_1">%2$s</xliff:g>"</string>
    <string name="bluetooth_battery_level" msgid="2893696778200201555">"Bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="bluetooth_battery_level_untethered" msgid="4002282355111504349">"L: Bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE_0">%1$s</xliff:g>, R: Bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE_1">%2$s</xliff:g>"</string>
    <string name="bluetooth_active_no_battery_level" msgid="4155462233006205630">"Aktiv"</string>
    <string name="bluetooth_profile_a2dp" msgid="4632426382762851724">"Audioja e klipit \"media\""</string>
    <string name="bluetooth_profile_headset" msgid="5395952236133499331">"Telefonatat"</string>
    <string name="bluetooth_profile_opp" msgid="6692618568149493430">"Transferimi i skedarëve"</string>
    <string name="bluetooth_profile_hid" msgid="2969922922664315866">"Pajisja e hyrjes"</string>
    <string name="bluetooth_profile_pan" msgid="1006235139308318188">"Qasja në internet"</string>
    <string name="bluetooth_profile_pbap" msgid="7064307749579335765">"Ndarja e kontakteve"</string>
    <string name="bluetooth_profile_pbap_summary" msgid="2955819694801952056">"Përdore për ndarjen e kontakteve"</string>
    <string name="bluetooth_profile_pan_nap" msgid="7871974753822470050">"Ndarja e lidhjes së internetit"</string>
    <string name="bluetooth_profile_map" msgid="8907204701162107271">"Mesazhet me tekst"</string>
    <string name="bluetooth_profile_sap" msgid="8304170950447934386">"Qasje në kartën SIM"</string>
    <string name="bluetooth_profile_a2dp_high_quality" msgid="4739440941324792775">"Audio HD: <xliff:g id="CODEC_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_profile_a2dp_high_quality_unknown_codec" msgid="2477639096903834374">"Audio HD"</string>
    <string name="bluetooth_profile_hearing_aid" msgid="58154575573984914">"Aparatet e dëgjimit"</string>
    <string name="bluetooth_hearing_aid_profile_summary_connected" msgid="8191273236809964030">"Lidhur me aparatet e dëgjimit"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="7422607970115444153">"U lidh me audion e medias"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="2420981566026949688">"U lidh me audion e telefonit"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2393521801478157362">"U lidh me serverin e transferimit të skedarëve"</string>
    <string name="bluetooth_map_profile_summary_connected" msgid="4141725591784669181">"U lidh me hartën"</string>
    <string name="bluetooth_sap_profile_summary_connected" msgid="1280297388033001037">"Lidhur me SAP"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="3959741824627764954">"Nuk u lidh me serverin e transferimit të skedarëve"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3923653977051684833">"U lidh me pajisjen e hyrjes"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="380469653827505727">"Lidhur me pajisjen për qasje në internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="3744773111299503493">"Po ndan lidhjen lokale të internetit me pajisjen"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="7422039765025340313">"Përdor për qasje në internet"</string>
    <string name="bluetooth_map_profile_summary_use_for" msgid="4453622103977592583">"Përdore për hartën"</string>
    <string name="bluetooth_sap_profile_summary_use_for" msgid="6204902866176714046">"Përdor për qasje në kartën SIM"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="7324694226276491807">"Përdor për audion e medias"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="808970643123744170">"Përdor për audion e telefonit"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="461981154387015457">"Përdor për transferimin e skedarëve"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="4289460627406490952">"Përdore për hyrjen"</string>
    <string name="bluetooth_hearing_aid_profile_summary_use_for" msgid="7689393730163320483">"Përdore për aparatet e dëgjimit"</string>
    <string name="bluetooth_pairing_accept" msgid="2054232610815498004">"Çifto"</string>
    <string name="bluetooth_pairing_accept_all_caps" msgid="2734383073450506220">"ÇIFTO"</string>
    <string name="bluetooth_pairing_decline" msgid="6483118841204885890">"Anulo"</string>
    <string name="bluetooth_pairing_will_share_phonebook" msgid="3064334458659165176">"Çiftimi lejon qasjen te kontaktet dhe historiku yt i telefonatave."</string>
    <string name="bluetooth_pairing_error_message" msgid="6626399020672335565">"Nuk mundi të çiftohej me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="264422127613704940">"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="2554424863101358857">"Nuk mund të komunikohet me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="5943444352777314442">"Çiftimi u refuzua nga <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_talkback_computer" msgid="3736623135703893773">"Kompjuteri"</string>
    <string name="bluetooth_talkback_headset" msgid="3406852564400882682">"Kufjet me mikrofon"</string>
    <string name="bluetooth_talkback_phone" msgid="868393783858123880">"Telefon"</string>
    <string name="bluetooth_talkback_imaging" msgid="8781682986822514331">"Imazhe"</string>
    <string name="bluetooth_talkback_headphone" msgid="8613073829180337091">"Kufje"</string>
    <string name="bluetooth_talkback_input_peripheral" msgid="5133944817800149942">"Hyrje periferike"</string>
    <string name="bluetooth_talkback_bluetooth" msgid="1143241359781999989">"Bluetooth-i"</string>
    <string name="bluetooth_hearingaid_left_pairing_message" msgid="8561855779703533591">"Aparati i dëgjimit majtas po çiftohet…"</string>
    <string name="bluetooth_hearingaid_right_pairing_message" msgid="2655347721696331048">"Aparati i dëgjimit djathtas po çiftohet…"</string>
    <string name="bluetooth_hearingaid_left_battery_level" msgid="7375621694748104876">"Majtas - bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="bluetooth_hearingaid_right_battery_level" msgid="1850094448499089312">"Djathtas - bateria <xliff:g id="BATTERY_LEVEL_AS_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="accessibility_wifi_off" msgid="1195445715254137155">"Wi-Fi është çaktivizuar."</string>
    <string name="accessibility_no_wifi" msgid="5297119459491085771">"Wi-Fi është i shkëputur."</string>
    <string name="accessibility_wifi_one_bar" msgid="6025652717281815212">"Wi-Fi ka një vijë."</string>
    <string name="accessibility_wifi_two_bars" msgid="687800024970972270">"Wi-Fi ka dy vija."</string>
    <string name="accessibility_wifi_three_bars" msgid="779895671061950234">"Wi-Fi: tre vija."</string>
    <string name="accessibility_wifi_signal_full" msgid="7165262794551355617">"Wi-Fi ka sinjal të plotë."</string>
    <string name="accessibility_wifi_security_type_none" msgid="162352241518066966">"Rrjet i hapur"</string>
    <string name="accessibility_wifi_security_type_secured" msgid="2399774097343238942">"Rrjet i sigurt"</string>
    <string name="process_kernel_label" msgid="950292573930336765">"Sistemi operativ Android"</string>
    <string name="data_usage_uninstalled_apps" msgid="1933665711856171491">"Aplikacionet e hequra"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="5533981546921913295">"Aplikacionet dhe përdoruesit e hequr"</string>
    <string name="data_usage_ota" msgid="7984667793701597001">"Përditësimet e sistemit"</string>
    <string name="tether_settings_title_usb" msgid="3728686573430917722">"Ndarje përmes USB-së"</string>
    <string name="tether_settings_title_wifi" msgid="4803402057533895526">"Zona e qasjes e lëvizshme"</string>
    <string name="tether_settings_title_bluetooth" msgid="916519902721399656">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="1727111807207577322">"Ndarja e internetit"</string>
    <string name="tether_settings_title_all" msgid="8910259483383010470">"Zonë qasjeje dhe ndarjeje interneti"</string>
    <string name="managed_user_title" msgid="449081789742645723">"Të gjitha aplikacionet e punës"</string>
    <string name="user_guest" msgid="6939192779649870792">"I ftuar"</string>
    <string name="unknown" msgid="3544487229740637809">"I panjohur"</string>
    <string name="running_process_item_user_label" msgid="3988506293099805796">"Përdoruesi: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="launch_defaults_some" msgid="3631650616557252926">"Disa caktime me parazgjedhje"</string>
    <string name="launch_defaults_none" msgid="8049374306261262709">"Nuk janë caktuar parazgjedhje"</string>
    <string name="tts_settings" msgid="8130616705989351312">"Cilësimet \"tekst-në-ligjërim\""</string>
    <string name="tts_settings_title" msgid="7602210956640483039">"Dalja \"tekst-në-ligjërim\""</string>
    <string name="tts_default_rate_title" msgid="3964187817364304022">"Shpejtësia e të folurit"</string>
    <string name="tts_default_rate_summary" msgid="3781937042151716987">"Shpejtësia me të cilën thuhet teksti"</string>
    <string name="tts_default_pitch_title" msgid="6988592215554485479">"Tonaliteti"</string>
    <string name="tts_default_pitch_summary" msgid="9132719475281551884">"Ndikon te toni i ligjërimit të sintetizuar"</string>
    <string name="tts_default_lang_title" msgid="4698933575028098940">"Gjuha"</string>
    <string name="tts_lang_use_system" msgid="6312945299804012406">"Përdor gjuhën e sistemit"</string>
    <string name="tts_lang_not_selected" msgid="7927823081096056147">"Nuk është përzgjedhur gjuha"</string>
    <string name="tts_default_lang_summary" msgid="9042620014800063470">"Cakton zërin specifik të gjuhës për tekstin e folur"</string>
    <string name="tts_play_example_title" msgid="1599468547216481684">"Dëgjo një shembull"</string>
    <string name="tts_play_example_summary" msgid="634044730710636383">"Luaj një demonstrim të shkurtër të sintezës së të folurit"</string>
    <string name="tts_install_data_title" msgid="1829942496472751703">"Instalo të dhënat e zërit"</string>
    <string name="tts_install_data_summary" msgid="3608874324992243851">"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="3372432853837988146">"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="8722087649733906851">"Kjo gjuhë kërkon një lidhje funksionale interneti për daljen \"tekst-në-ligjërim\"."</string>
    <string name="tts_default_sample_string" msgid="6388016028292967973">"Ky është një shembull i sintezës së të folurit"</string>
    <string name="tts_status_title" msgid="8190784181389278640">"Statusi i gjuhës së parazgjedhur"</string>
    <string name="tts_status_ok" msgid="8583076006537547379">"<xliff:g id="LOCALE">%1$s</xliff:g> mbështetet plotësisht"</string>
    <string name="tts_status_requires_network" msgid="8327617638884678896">"<xliff:g id="LOCALE">%1$s</xliff:g> kërkon lidhje interneti"</string>
    <string name="tts_status_not_supported" msgid="2702997696245523743">"<xliff:g id="LOCALE">%1$s</xliff:g> nuk mbështetet"</string>
    <string name="tts_status_checking" msgid="8026559918948285013">"Po kontrollon..."</string>
    <string name="tts_engine_settings_title" msgid="7849477533103566291">"Cilësimet për \"<xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>\""</string>
    <string name="tts_engine_settings_button" msgid="477155276199968948">"Hap cilësimet e motorit"</string>
    <string name="tts_engine_preference_section_title" msgid="3861562305498624904">"Motori i preferuar"</string>
    <string name="tts_general_section_title" msgid="8919671529502364567">"Të përgjithshme"</string>
    <string name="tts_reset_speech_pitch_title" msgid="7149398585468413246">"Rivendose tonin e të folurit."</string>
    <string name="tts_reset_speech_pitch_summary" msgid="6822904157021406449">"Rivendose te parazgjedhja tonin e të folurit për tekstin."</string>
  <string-array name="tts_rate_entries">
    <item msgid="9004239613505400644">"Shumë e ulët"</item>
    <item msgid="1815382991399815061">"E ngadaltë"</item>
    <item msgid="3075292553049300105">"Normale"</item>
    <item msgid="1158955023692670059">"E shpejtë"</item>
    <item msgid="5664310435707146591">"Më e shpejtë"</item>
    <item msgid="5491266922147715962">"Shumë e shpejtë"</item>
    <item msgid="7659240015901486196">"E shpejtë"</item>
    <item msgid="7147051179282410945">"Shumë e shpejtë"</item>
    <item msgid="581904787661470707">"Më e shpejta"</item>
  </string-array>
    <string name="choose_profile" msgid="343803890897657450">"Zgjidh profilin"</string>
    <string name="category_personal" msgid="6236798763159385225">"Personale"</string>
    <string name="category_work" msgid="4014193632325996115">"Punë"</string>
    <string name="development_settings_title" msgid="140296922921597393">"Opsionet e zhvilluesit"</string>
    <string name="development_settings_enable" msgid="4285094651288242183">"Aktivizo opsionet e zhvilluesit"</string>
    <string name="development_settings_summary" msgid="8718917813868735095">"Cakto opsionet për zhvillimin e aplikacionit"</string>
    <string name="development_settings_not_available" msgid="355070198089140951">"Opsionet e programuesit nuk mundësohen për këtë përdorues"</string>
    <string name="vpn_settings_not_available" msgid="2894137119965668920">"Cilësimet e VPN-së nuk ofrohen për këtë përdorues"</string>
    <string name="tethering_settings_not_available" msgid="266821736434699780">"Cilësimet e ndarjes nuk ofrohen për këtë përdorues"</string>
    <string name="apn_settings_not_available" msgid="1147111671403342300">"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="8072776357237289039">"Korrigjimi i USB-së"</string>
    <string name="enable_adb_summary" msgid="3711526030096574316">"Korrigjo gabimet e modalitetit kur UBS-ja është e lidhur"</string>
    <string name="clear_adb_keys" msgid="3010148733140369917">"Anulo autorizimet e korrigjimeve të gabimeve të USB-së"</string>
    <string name="enable_adb_wireless" msgid="6973226350963971018">"Korrigjimi përmes Wi-Fi"</string>
    <string name="enable_adb_wireless_summary" msgid="7344391423657093011">"Modaliteti i korrigjimit kur Wi‑Fi është i lidhur"</string>
    <string name="adb_wireless_error" msgid="721958772149779856">"Gabim"</string>
    <string name="adb_wireless_settings" msgid="2295017847215680229">"Korrigjimi përmes Wi-Fi"</string>
    <string name="adb_wireless_list_empty_off" msgid="1713707973837255490">"Për të parë dhe përdorur pajisjet e disponueshme, aktivizo korrigjimin përmes Wi-Fi"</string>
    <string name="adb_pair_method_qrcode_title" msgid="6982904096137468634">"Çifto pajisjen me kod QR"</string>
    <string name="adb_pair_method_qrcode_summary" msgid="7130694277228970888">"Çifto pajisjet e reja duke përdorur skanerin e kodeve QR"</string>
    <string name="adb_pair_method_code_title" msgid="1122590300445142904">"Çifto pajisjen me kodin e çiftimit"</string>
    <string name="adb_pair_method_code_summary" msgid="6370414511333685185">"Çifto pajisjet e reja duke përdorur kodin me gjashtë shifra"</string>
    <string name="adb_paired_devices_title" msgid="5268997341526217362">"Pajisjet e çiftuara"</string>
    <string name="adb_wireless_device_connected_summary" msgid="3039660790249148713">"Të lidhur aktualisht"</string>
    <string name="adb_wireless_device_details_title" msgid="7129369670526565786">"Detajet e pajisjes"</string>
    <string name="adb_device_forget" msgid="193072400783068417">"Harro"</string>
    <string name="adb_device_fingerprint_title_format" msgid="291504822917843701">"Gjurma e gishtit e pajisjes: <xliff:g id="FINGERPRINT_PARAM">%1$s</xliff:g>"</string>
    <string name="adb_wireless_connection_failed_title" msgid="664211177427438438">"Lidhja ishte e pasuksesshme"</string>
    <string name="adb_wireless_connection_failed_message" msgid="9213896700171602073">"Sigurohu që <xliff:g id="DEVICE_NAME">%1$s</xliff:g> të jetë e lidhur me rrjetin e duhur"</string>
    <string name="adb_pairing_device_dialog_title" msgid="7141739231018530210">"Çifto me pajisjen"</string>
    <string name="adb_pairing_device_dialog_pairing_code_label" msgid="3639239786669722731">"Kodi i çiftimit të Wi‑Fi"</string>
    <string name="adb_pairing_device_dialog_failed_title" msgid="3426758947882091735">"Çiftimi ishte i pasuksesshëm"</string>
    <string name="adb_pairing_device_dialog_failed_msg" msgid="6611097519661997148">"Sigurohu që pajisja të jetë e lidhur me të njëjtin rrjet"</string>
    <string name="adb_wireless_qrcode_summary" msgid="8051414549011801917">"Çifto pajisjen përmes Wi‑Fi duke skanuar një kod QR"</string>
    <string name="adb_wireless_verifying_qrcode_text" msgid="6123192424916029207">"Po çifton pajisjen…"</string>
    <string name="adb_qrcode_pairing_device_failed_msg" msgid="6936292092592914132">"Çiftimi i pajisjes dështoi. Ose kodi QR nuk ishte i saktë, ose pajisja nuk është e lidhur me të njëjtin rrjet."</string>
    <string name="adb_wireless_ip_addr_preference_title" msgid="8335132107715311730">"Adresa e IP-së dhe porta"</string>
    <string name="adb_wireless_qrcode_pairing_title" msgid="1906409667944674707">"Skano kodin QR"</string>
    <string name="adb_wireless_qrcode_pairing_description" msgid="6014121407143607851">"Çifto pajisjen përmes Wi‑Fi duke skanuar një kod QR"</string>
    <string name="adb_wireless_no_network_msg" msgid="2365795244718494658">"Lidhu me një rrjet Wi-Fi"</string>
    <string name="keywords_adb_wireless" msgid="6507505581882171240">"adb, korrigjimi, zhvilluesi"</string>
    <string name="bugreport_in_power" msgid="8664089072534638709">"Shkurtorja e raportit të defektit në kod"</string>
    <string name="bugreport_in_power_summary" msgid="1885529649381831775">"Shfaq një buton në menynë e fikjes për marrjen e raportit të defekteve"</string>
    <string name="keep_screen_on" msgid="1187161672348797558">"Qëndro zgjuar"</string>
    <string name="keep_screen_on_summary" msgid="1510731514101925829">"Ekrani nuk do të kalojë asnjëherë në gjendje gjumi gjatë karikimit"</string>
    <string name="bt_hci_snoop_log" msgid="7291287955649081448">"Aktivizo regjistrin testues të paketave HCI të Bluetooth-it"</string>
    <string name="bt_hci_snoop_log_summary" msgid="6808538971394092284">"Regjistro paketat e Bluetooth-it. (Ndrysho Bluetooth-in pas ndryshimit të këtij cilësimi)"</string>
    <string name="oem_unlock_enable" msgid="5334869171871566731">"Shkyçja e OEM-së"</string>
    <string name="oem_unlock_enable_summary" msgid="5857388174390953829">"Lejo shkyçjen e ngarkimit të sistemit"</string>
    <string name="confirm_enable_oem_unlock_title" msgid="8249318129774367535">"Të lejohet shkyçja e OEM-së?"</string>
    <string name="confirm_enable_oem_unlock_text" msgid="854131050791011970">"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="6269380172542248304">"Zgjidh apl. që simulon vendndodhjen"</string>
    <string name="mock_location_app_not_set" msgid="6972032787262831155">"Nuk është vendosur asnjë aplikacion që simulon vendndodhjen"</string>
    <string name="mock_location_app_set" msgid="4706722469342913843">"Aplikacioni për simulimin e vendndodhjes: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="debug_networking_category" msgid="6829757985772659599">"Rrjetet"</string>
    <string name="wifi_display_certification" msgid="1805579519992520381">"Certifikimi i ekranit valor"</string>
    <string name="wifi_verbose_logging" msgid="1785910450009679371">"Aktivizo hyrjen Wi-Fi Verbose"</string>
    <string name="wifi_scan_throttling" msgid="2985624788509913617">"Përshpejtimi i skanimit të Wi‑Fi"</string>
    <string name="wifi_enhanced_mac_randomization" msgid="5437378364995776979">"Renditja e rastësishme e adresave MAC të përmirësuara me Wi-Fi"</string>
    <string name="mobile_data_always_on" msgid="8275958101875563572">"Të dhënat celulare gjithmonë aktive"</string>
    <string name="tethering_hardware_offload" msgid="4116053719006939161">"Përshpejtimi i harduerit për ndarjen e lidhjes (internet)"</string>
    <string name="bluetooth_show_devices_without_names" msgid="923584526471885819">"Shfaq pajisjet me Bluetooth pa emra"</string>
    <string name="bluetooth_disable_absolute_volume" msgid="1452342324349203434">"Çaktivizo volumin absolut"</string>
    <string name="bluetooth_enable_gabeldorsche" msgid="9131730396242883416">"Aktivizo Gabeldorsche"</string>
    <string name="enhanced_connectivity" msgid="7201127377781666804">"Lidhshmëria e përmirësuar"</string>
    <string name="bluetooth_select_avrcp_version_string" msgid="1710571610177659127">"Versioni AVRCP i Bluetooth-it"</string>
    <string name="bluetooth_select_avrcp_version_dialog_title" msgid="7846922290083709633">"Zgjidh versionin AVRCP të Bluetooth-it"</string>
    <string name="bluetooth_select_map_version_string" msgid="526308145174175327">"Versioni MAP i Bluetooth-it"</string>
    <string name="bluetooth_select_map_version_dialog_title" msgid="7085934373987428460">"Zgjidh versionin MAP të Bluetooth-it"</string>
    <string name="bluetooth_select_a2dp_codec_type" msgid="952001408455456494">"Kodeku Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_type_dialog_title" msgid="7510542404227225545">"Aktivizo kodekun e audios me Bluetooth\nZgjedhja"</string>
    <string name="bluetooth_select_a2dp_codec_sample_rate" msgid="1638623076480928191">"Shpejtësia e shembullit të Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_sample_rate_dialog_title" msgid="5876305103137067798">"Aktivizo kodekun e audios me Bluetooth\nZgjedhja: Shpejtësia e shembullit"</string>
    <string name="bluetooth_select_a2dp_codec_type_help_info" msgid="8647200416514412338">"Çaktivizimi do të thotë se nuk mbështetet nga telefoni ose kufjet"</string>
    <string name="bluetooth_select_a2dp_codec_bits_per_sample" msgid="6253965294594390806">"Bite për shembull Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_bits_per_sample_dialog_title" msgid="4898693684282596143">"Aktivizo kodekun e audios me Bluetooth\nZgjedhja: Bite për shembull"</string>
    <string name="bluetooth_select_a2dp_codec_channel_mode" msgid="364277285688014427">"Regjimi i kanalit Bluetooth Audio"</string>
    <string name="bluetooth_select_a2dp_codec_channel_mode_dialog_title" msgid="2076949781460359589">"Aktivizo kodekun e audios me Bluetooth\nZgjedhja: Modaliteti i kanalit"</string>
    <string name="bluetooth_select_a2dp_codec_ldac_playback_quality" msgid="3233402355917446304">"Kodeku LDAC i audios së Bluetooth-it: Cilësia e luajtjes"</string>
    <string name="bluetooth_select_a2dp_codec_ldac_playback_quality_dialog_title" msgid="7274396574659784285">"Aktivizo LDAC të audios me Bluetooth\nZgjedhja e kodekut: Cilësia e luajtjes"</string>
    <string name="bluetooth_select_a2dp_codec_streaming_label" msgid="2040810756832027227">"Transmetimi: <xliff:g id="STREAMING_PARAMETER">%1$s</xliff:g>"</string>
    <string name="select_private_dns_configuration_title" msgid="7887550926056143018">"DNS-ja private"</string>
    <string name="select_private_dns_configuration_dialog_title" msgid="3731422918335951912">"Zgjidh modalitetin e DNS-së private"</string>
    <string name="private_dns_mode_off" msgid="7065962499349997041">"Joaktiv"</string>
    <string name="private_dns_mode_opportunistic" msgid="1947864819060442354">"Automatik"</string>
    <string name="private_dns_mode_provider" msgid="3619040641762557028">"Emri i pritësit të ofruesit të DNS-së private"</string>
    <string name="private_dns_mode_provider_hostname_hint" msgid="6564868953748514595">"Fut emrin e pritësit të ofruesit të DNS-së"</string>
    <string name="private_dns_mode_provider_failure" msgid="8356259467861515108">"Nuk mund të lidhej"</string>
    <string name="wifi_display_certification_summary" msgid="8111151348106907513">"Shfaq opsionet për certifikimin e ekranit valor"</string>
    <string name="wifi_verbose_logging_summary" msgid="4993823188807767892">"Rrit nivelin regjistrues të Wi‑Fi duke shfaqur SSID RSSI-në te Zgjedhësi i Wi‑Fi"</string>
    <string name="wifi_scan_throttling_summary" msgid="2577105472017362814">"Zvogëlon shkarkimin e baterisë dhe përmirëson cilësinë e funksionimit të rrjetit"</string>
    <string name="wifi_enhanced_mac_randomization_summary" msgid="1210663439867489931">"Kur ky modalitet është i aktivizuar, adresa MAC e kësaj pajisjeje mund të ndryshojë çdo herë që lidhet me një rrjet që ka të aktivizuar renditjen e rastësishme të adresave MAC."</string>
    <string name="wifi_metered_label" msgid="8737187690304098638">"Me matje"</string>
    <string name="wifi_unmetered_label" msgid="6174142840934095093">"Pa matje"</string>
    <string name="select_logd_size_title" msgid="1604578195914595173">"Madhësitë e regjistruesit"</string>
    <string name="select_logd_size_dialog_title" msgid="2105401994681013578">"Përzgjidh madhësitë e regjistruesit"</string>
    <string name="dev_logpersist_clear_warning_title" msgid="8631859265777337991">"Do të pastrosh hapësirën ruajtëse të vazhdueshme të regjistruesit?"</string>
    <string name="dev_logpersist_clear_warning_message" msgid="6447590867594287413">"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="447071974007104196">"Ruaj të dhënat e regjistruesit vazhdimisht në pajisje"</string>
    <string name="select_logpersist_dialog_title" msgid="7745193591195485594">"Zgjidh memoriet e regjistrit për të ruajtur vazhdimisht në pajisje"</string>
    <string name="select_usb_configuration_title" msgid="6339801314922294586">"Konfigurimi i USB-së"</string>
    <string name="select_usb_configuration_dialog_title" msgid="3579567144722589237">"Konfigurimi i USB-së"</string>
    <string name="allow_mock_location" msgid="2102650981552527884">"Lejo vendndodhje të simuluara"</string>
    <string name="allow_mock_location_summary" msgid="179780881081354579">"Lejo vendndodhje të simuluara"</string>
    <string name="debug_view_attributes" msgid="3539609843984208216">"Aktivizo shikimin e inspektimit të atributeve"</string>
    <string name="mobile_data_always_on_summary" msgid="1112156365594371019">"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="7801345335142803029">"Përdor përshpejtimin e harduerit për ndarjen e lidhjes (internet) nëse është i disponueshëm"</string>
    <string name="adb_warning_title" msgid="7708653449506485728">"Të lejohet korrigjimi i USB-së?"</string>
    <string name="adb_warning_message" msgid="8145270656419669221">"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="adbwifi_warning_title" msgid="727104571653031865">"Të lejohet korrigjimi përmes Wi-Fi?"</string>
    <string name="adbwifi_warning_message" msgid="8005936574322702388">"Korrigjimin përmes Wi-Fi është vetëm për qëllime zhvillimore. Përdore për të kopjuar të dhëna mes kompjuterit dhe pajisjes sate, për të instaluar aplikacione në pajisjen tënde pa asnjë njoftim si dhe për të lexuar të dhënat e regjistrit."</string>
    <string name="adb_keys_warning_message" msgid="2968555274488101220">"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="8251234890169074553">"Të lejohen cilësimet e zhvillimit?"</string>
    <string name="dev_settings_warning_message" msgid="37741686486073668">"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="6031809675604442636">"Verifiko apl. përmes USB-së"</string>
    <string name="verify_apps_over_usb_summary" msgid="1317933737581167839">"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="780964354377854507">"Pajisjet me Bluetooth do të shfaqen pa emra (vetëm adresat MAC)"</string>
    <string name="bluetooth_disable_absolute_volume_summary" msgid="2006309932135547681">"Ç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="bluetooth_enable_gabeldorsche_summary" msgid="2054730331770712629">"Aktivizon grupin e veçorive të Bluetooth Gabeldorsche."</string>
    <string name="enhanced_connectivity_summary" msgid="1576414159820676330">"Aktivizon veçorinë e \"Lidhshmërisë së përmirësuar\"."</string>
    <string name="enable_terminal_title" msgid="3834790541986303654">"Terminali lokal"</string>
    <string name="enable_terminal_summary" msgid="2481074834856064500">"Aktivizo aplikacionin terminal që ofron qasje në guaskën lokale"</string>
    <string name="hdcp_checking_title" msgid="3155692785074095986">"Kontrolli HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="7691060297616217781">"Cakto kontrollin e HDCP-së"</string>
    <string name="debug_debugging_category" msgid="535341063709248842">"Korrigjimi i gabimeve"</string>
    <string name="debug_app" msgid="8903350241392391766">"Zgjidh aplikacionin e korrigjimit"</string>
    <string name="debug_app_not_set" msgid="1934083001283807188">"Nuk është caktuar asnjë aplikacion korrigjimi"</string>
    <string name="debug_app_set" msgid="6599535090477753651">"Aplikacioni i korrigjimit: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="2543228890535466325">"Zgjidh aplikacionin"</string>
    <string name="no_application" msgid="9038334538870247690">"Asnjë"</string>
    <string name="wait_for_debugger" msgid="7461199843335409809">"Prit për korrigjuesin"</string>
    <string name="wait_for_debugger_summary" msgid="6846330006113363286">"Aplikacioni i korrigjimit të gabimeve pret që korrigjuesi të bashkëngjitet para ekzekutimit"</string>
    <string name="debug_input_category" msgid="7349460906970849771">"Hyrja"</string>
    <string name="debug_drawing_category" msgid="5066171112313666619">"Vizatime"</string>
    <string name="debug_hw_drawing_category" msgid="5830815169336975162">"Interpretimi i përshpejtuar i harduerit"</string>
    <string name="media_category" msgid="8122076702526144053">"Media"</string>
    <string name="debug_monitoring_category" msgid="1597387133765424994">"Monitorimi"</string>
    <string name="strict_mode" msgid="889864762140862437">"Aktivizo modalitetin e rreptë"</string>
    <string name="strict_mode_summary" msgid="1838248687233554654">"Ndriço ekranin kur aplikacionet kryejnë operacione të gjata teksa bashkëveprojnë"</string>
    <string name="pointer_location" msgid="7516929526199520173">"Vendndodhja e treguesit"</string>
    <string name="pointer_location_summary" msgid="957120116989798464">"Mbivendosja e ekranit tregon të dhënat e prekjes"</string>
    <string name="show_touches" msgid="8437666942161289025">"Shfaq trokitjet"</string>
    <string name="show_touches_summary" msgid="3692861665994502193">"Shfaq reagimet vizuale për trokitjet"</string>
    <string name="show_screen_updates" msgid="2078782895825535494">"Shfaq përditësimet e sipërfaqes"</string>
    <string name="show_screen_updates_summary" msgid="2126932969682087406">"Ndriço të gjitha sipërfaqet e dritares kur ato të përditësohen"</string>
    <string name="show_hw_screen_updates" msgid="2021286231267747506">"Shfaq përditësimet e pamjes"</string>
    <string name="show_hw_screen_updates_summary" msgid="3539770072741435691">"Ndriço pamjet brenda dritareve kur dizajnohen"</string>
    <string name="show_hw_layers_updates" msgid="5268370750002509767">"Shfaq përditësimet e shtresave të harduerit"</string>
    <string name="show_hw_layers_updates_summary" msgid="5850955890493054618">"Ndriço në të gjelbër shtresat e harduerit që përditësohen"</string>
    <string name="debug_hw_overdraw" msgid="8944851091008756796">"Korrigjo konfliktet e GPU-së"</string>
    <string name="disable_overlays" msgid="4206590799671557143">"Çaktivizo mbishtresimin e HW-së"</string>
    <string name="disable_overlays_summary" msgid="1954852414363338166">"Përdor gjithmonë GPU-në për përbërjen e ekranit"</string>
    <string name="simulate_color_space" msgid="1206503300335835151">"Simulo hapësirën e ngjyrës"</string>
    <string name="enable_opengl_traces_title" msgid="4638773318659125196">"Aktivizo gjurmët e OpenGL-së"</string>
    <string name="usb_audio_disable_routing" msgid="3367656923544254975">"Çaktivizo rrugëzuezin e audios përmes USB-së"</string>
    <string name="usb_audio_disable_routing_summary" msgid="8768242894849534699">"Çaktivizo router-in automatik për te kufjet ose altoparlantët"</string>
    <string name="debug_layout" msgid="1659216803043339741">"Shfaq konturet e kuadrit"</string>
    <string name="debug_layout_summary" msgid="8825829038287321978">"Shfaq konturet e klipit, hapësirat etj."</string>
    <string name="force_rtl_layout_all_locales" msgid="8690762598501599796">"Detyro drejtimin e shkrimit nga e djathta në të majtë"</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="6663016859517239880">"Ndrysho me detyrim drejtimin e planit të ekranit nga e djathta në të majtë për të gjitha vendet"</string>
    <string name="force_msaa" msgid="4081288296137775550">"Detyro 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9070437493586769500">"Aktivizo 4x MSAA në aplikacionet OpenGL ES 2.0"</string>
    <string name="show_non_rect_clip" msgid="7499758654867881817">"Korrigjo veprimet mbi klipet jodrejtkëndore"</string>
    <string name="track_frame_time" msgid="522674651937771106">"Interpretimi i profilit me HWUI"</string>
    <string name="enable_gpu_debug_layers" msgid="4986675516188740397">"Aktivizo shtresat e korrigjimit të GPU-së"</string>
    <string name="enable_gpu_debug_layers_summary" msgid="4921521407377170481">"Lejo ngarkimin e shtresave të korrigjimit të GPU-së për aplikacionet e korrigjimit"</string>
    <string name="enable_verbose_vendor_logging" msgid="1196698788267682072">"Aktivizo evidencat e tregtuesit me shumë fjalë"</string>
    <string name="enable_verbose_vendor_logging_summary" msgid="5426292185780393708">"Përfshi evidenca shtesë të treguesve specifike për pajisjen në raportet e defekteve, që mund të përfshijnë informacion privat, mund të përdorin më shumë bateri dhe/ose të përdorin më shumë hapësirë ruajtëse."</string>
    <string name="window_animation_scale_title" msgid="5236381298376812508">"Animacioni i dritares"</string>
    <string name="transition_animation_scale_title" msgid="1278477690695439337">"Animacioni kalimtar"</string>
    <string name="animator_duration_scale_title" msgid="7082913931326085176">"Kohëzgjatja e animatorit"</string>
    <string name="overlay_display_devices_title" msgid="5411894622334469607">"Simulo ekranet dytësore"</string>
    <string name="debug_applications_category" msgid="5394089406638954196">"Aplikacionet"</string>
    <string name="immediately_destroy_activities" msgid="1826287490705167403">"Mos i ruaj aktivitetet"</string>
    <string name="immediately_destroy_activities_summary" msgid="6289590341144557614">"Fshi çdo aktivitet sapo të largohet përdoruesi"</string>
    <string name="app_process_limit_title" msgid="8361367869453043007">"Kufizimi i proceseve në sfond"</string>
    <string name="show_all_anrs" msgid="9160563836616468726">"Shfaq raportet ANR të sfondit"</string>
    <string name="show_all_anrs_summary" msgid="8562788834431971392">"Shfaq raportet ANR (Aplikacioni nuk përgjigjet) për aplikacionet në sfond"</string>
    <string name="show_notification_channel_warnings" msgid="3448282400127597331">"Shfaq paralajmërimet e kanalit të njoftimeve"</string>
    <string name="show_notification_channel_warnings_summary" msgid="68031143745094339">"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="9187902444231637880">"Detyro lejimin në hapësirën e jashtme"</string>
    <string name="force_allow_on_external_summary" msgid="8525425782530728238">"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="7143612144399959606">"Detyro madhësinë e ndryshueshme për aktivitetet"</string>
    <string name="force_resizable_activities_summary" msgid="2490382056981583062">"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="7599125687603914253">"Aktivizo dritaret me formë të lirë"</string>
    <string name="enable_freeform_support_summary" msgid="1822862728719276331">"Aktivizo mbështetjen për dritaret eksperimentale me formë të lirë."</string>
    <string name="local_backup_password_title" msgid="4631017948933578709">"Fjalëkalimi rezervë i kompjuterit"</string>
    <string name="local_backup_password_summary_none" msgid="7646898032616361714">"Rezervimet e plota në kompjuter nuk janë të mbrojtura aktualisht"</string>
    <string name="local_backup_password_summary_change" msgid="1707357670383995567">"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="4891666204428091604">"Fjalëkalimi i ri u vendos"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="2994718182129097733">"Fjalëkalimi i ri dhe konfirmimi nuk përputhen"</string>
    <string name="local_backup_password_toast_validation_failure" msgid="714669442363647122">"Vendosja e fjalëkalimit dështoi"</string>
    <string name="loading_injected_setting_summary" msgid="8394446285689070348">"Po ngarkohet…"</string>
  <string-array name="color_mode_names">
    <item msgid="3836559907767149216">"Të gjalla (parazgjedhja)"</item>
    <item msgid="9112200311983078311">"Natyrale"</item>
    <item msgid="6564241960833766170">"Standarde"</item>
  </string-array>
  <string-array name="color_mode_descriptions">
    <item msgid="6828141153199944847">"Ngjyra të përmirësuara"</item>
    <item msgid="4548987861791236754">"Ngjyra natyrale siç shikohen me sy të lirë"</item>
    <item msgid="1282170165150762976">"Ngjyra të optimizuara për përmbajtjet dixhitale"</item>
  </string-array>
    <string name="inactive_apps_title" msgid="5372523625297212320">"Aplikacionet në gatishmëri"</string>
    <string name="inactive_app_inactive_summary" msgid="3161222402614236260">"Joaktiv. Trokit për ta ndryshuar."</string>
    <string name="inactive_app_active_summary" msgid="8047630990208722344">"Aktiv. Trokit për ta ndryshuar."</string>
    <string name="standby_bucket_summary" msgid="5128193447550429600">"Gjendja e gatishmërisë e aplikacionit:<xliff:g id="BUCKET"> %s</xliff:g>"</string>
    <string name="runningservices_settings_title" msgid="6460099290493086515">"Shërbimet në ekzekutim"</string>
    <string name="runningservices_settings_summary" msgid="1046080643262665743">"Shiko dhe kontrollo shërbimet që po ekzekutohen aktualisht"</string>
    <string name="select_webview_provider_title" msgid="3917815648099445503">"Zbatimi i WebView"</string>
    <string name="select_webview_provider_dialog_title" msgid="2444261109877277714">"Cakto zbatimin e WebView"</string>
    <string name="select_webview_provider_toast_text" msgid="8512254949169359848">"Kjo zgjedhje nuk është më e vlefshme. Provo përsëri."</string>
    <string name="convert_to_file_encryption" msgid="2828976934129751818">"Konverto në enkriptimin e skedarit"</string>
    <string name="convert_to_file_encryption_enabled" msgid="840757431284311754">"Konverto..."</string>
    <string name="convert_to_file_encryption_done" msgid="8965831011811180627">"Enkriptimi i skedarit është kryer tashmë"</string>
    <string name="title_convert_fbe" msgid="5780013350366495149">"Po konvertohet në enkriptimin e bazuar te skedari"</string>
    <string name="convert_to_fbe_warning" msgid="34294381569282109">"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="1159861795137727671">"Pastro dhe konverto..."</string>
    <string name="picture_color_mode" msgid="1013807330552931903">"Modalitti i ngjyrave të figurës"</string>
    <string name="picture_color_mode_desc" msgid="151780973768136200">"Përdor sRGB"</string>
    <string name="daltonizer_mode_disabled" msgid="403424372812399228">"Çaktivizuar"</string>
    <string name="daltonizer_mode_monochromacy" msgid="362060873835885014">"Monokromaci"</string>
    <string name="daltonizer_mode_deuteranomaly" msgid="3507284319584683963">"Deuteranomali (e kuqe - e gjelbër)"</string>
    <string name="daltonizer_mode_protanomaly" msgid="7805583306666608440">"Protanomali (e kuqe - e gjelbër)"</string>
    <string name="daltonizer_mode_tritanomaly" msgid="7135266249220732267">"Tritanomali (e kaltër - e verdhë)"</string>
    <string name="accessibility_display_daltonizer_preference_title" msgid="1810693571332381974">"Korrigjimi i ngjyrës"</string>
    <string name="accessibility_display_daltonizer_preference_subtitle" msgid="1284746051652993443">"Korrigjimi i ngjyrave të lejon të rregullosh mënyrën se si shfaqen ngjyrat në pajisjen tënde"</string>
    <string name="daltonizer_type_overridden" msgid="4509604753672535721">"Mbivendosur nga <xliff:g id="TITLE">%1$s</xliff:g>"</string>
    <string name="power_remaining_settings_home_page" msgid="4885165789445462557">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> - <xliff:g id="TIME_STRING">%2$s</xliff:g>"</string>
    <string name="power_remaining_duration_only" msgid="8264199158671531431">"Rreth <xliff:g id="TIME_REMAINING">%1$s</xliff:g> të mbetura"</string>
    <string name="power_discharging_duration" msgid="1076561255466053220">"Rreth <xliff:g id="TIME_REMAINING">%1$s</xliff:g> të mbetura (<xliff:g id="LEVEL">%2$s</xliff:g>)"</string>
    <string name="power_remaining_duration_only_enhanced" msgid="2527842780666073218">"Rreth <xliff:g id="TIME_REMAINING">%1$s</xliff:g> të mbetura bazuar në përdorimin tënd"</string>
    <string name="power_discharging_duration_enhanced" msgid="1800465736237672323">"Rreth <xliff:g id="TIME_REMAINING">%1$s</xliff:g> të mbetura bazuar në përdorimin tënd (<xliff:g id="LEVEL">%2$s</xliff:g>)"</string>
    <!-- no translation found for power_remaining_duration_only_short (7438846066602840588) -->
    <skip />
    <string name="power_discharge_by_enhanced" msgid="563438403581662942">"Duhet të zgjasë deri në rreth <xliff:g id="TIME">%1$s</xliff:g> bazuar në përdorimin tënd (<xliff:g id="LEVEL">%2$s</xliff:g>)"</string>
    <string name="power_discharge_by_only_enhanced" msgid="3268796172652988877">"Duhet të zgjasë deri në rreth <xliff:g id="TIME">%1$s</xliff:g> bazuar në përdorimin tënd"</string>
    <string name="power_discharge_by" msgid="4113180890060388350">"Duhet të zgjasë deri në rreth <xliff:g id="TIME">%1$s</xliff:g> (<xliff:g id="LEVEL">%2$s</xliff:g>)"</string>
    <string name="power_discharge_by_only" msgid="92545648425937000">"Duhet të zgjasë deri në rreth <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="power_discharge_by_only_short" msgid="5883041507426914446">"Deri në <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="power_suggestion_battery_run_out" msgid="6332089307827787087">"Bateria mund të mbarojë deri në <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="power_remaining_less_than_duration_only" msgid="8956656616031395152">"Më pak se <xliff:g id="THRESHOLD">%1$s</xliff:g> e mbetur"</string>
    <string name="power_remaining_less_than_duration" msgid="318215464914990578">"Më pak se <xliff:g id="THRESHOLD">%1$s</xliff:g> e mbetur (<xliff:g id="LEVEL">%2$s</xliff:g>)"</string>
    <string name="power_remaining_more_than_subtext" msgid="446388082266121894">"Më shumë se <xliff:g id="TIME_REMAINING">%1$s</xliff:g> e mbetur (<xliff:g id="LEVEL">%2$s</xliff:g>)"</string>
    <string name="power_remaining_only_more_than_subtext" msgid="4873750633368888062">"Më shumë se <xliff:g id="TIME_REMAINING">%1$s</xliff:g> e mbetur"</string>
    <string name="power_remaining_duration_only_shutdown_imminent" product="default" msgid="137330009791560774">"Telefoni mund të fiket së shpejti"</string>
    <string name="power_remaining_duration_only_shutdown_imminent" product="tablet" msgid="145489081521468132">"Tableti mund të fiket së shpejti"</string>
    <string name="power_remaining_duration_only_shutdown_imminent" product="device" msgid="1070562682853942350">"Pajisja mund të fiket së shpejti"</string>
    <string name="power_remaining_duration_shutdown_imminent" product="default" msgid="4429259621177089719">"Telefoni mund të fiket së shpejti (<xliff:g id="LEVEL">%1$s</xliff:g>)"</string>
    <string name="power_remaining_duration_shutdown_imminent" product="tablet" msgid="7703677921000858479">"Tableti mund të fiket së shpejti (<xliff:g id="LEVEL">%1$s</xliff:g>)"</string>
    <string name="power_remaining_duration_shutdown_imminent" product="device" msgid="4374784375644214578">"Pajisja mund të fiket së shpejti (<xliff:g id="LEVEL">%1$s</xliff:g>)"</string>
    <string name="power_charging" msgid="6727132649743436802">"<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="7415639699283965818">"<xliff:g id="TIME">%1$s</xliff:g> të mbetura deri në karikim"</string>
    <string name="power_charging_duration" msgid="5005740040558984057">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="TIME">%2$s</xliff:g> derisa të karikohet"</string>
    <string name="battery_info_status_unknown" msgid="268625384868401114">"I panjohur"</string>
    <string name="battery_info_status_charging" msgid="4279958015430387405">"Po karikohet"</string>
    <string name="battery_info_status_charging_fast" msgid="8027559755902954885">"Po ngarkon me shpejtësi"</string>
    <string name="battery_info_status_charging_slow" msgid="3190803837168962319">"Po karikohet ngadalë"</string>
    <string name="battery_info_status_discharging" msgid="6962689305413556485">"Nuk po karikohet"</string>
    <string name="battery_info_status_not_charging" msgid="8330015078868707899">"Në prizë, por nuk mund të karikohet për momentin"</string>
    <string name="battery_info_status_full" msgid="4443168946046847468">"E mbushur"</string>
    <string name="disabled_by_admin_summary_text" msgid="5343911767402923057">"Kontrolluar nga administratori"</string>
    <string name="disabled" msgid="8017887509554714950">"Çaktivizuar"</string>
    <string name="external_source_trusted" msgid="1146522036773132905">"Lejohet"</string>
    <string name="external_source_untrusted" msgid="5037891688911672227">"Nuk lejohet"</string>
    <string name="install_other_apps" msgid="3232595082023199454">"Instalo aplikacione të panjohura"</string>
    <string name="home" msgid="973834627243661438">"Kreu i cilësimeve"</string>
  <string-array name="battery_labels">
    <item msgid="7878690469765357158">"0%"</item>
    <item msgid="8894873528875953317">"50%"</item>
    <item msgid="7529124349186240216">"100%"</item>
  </string-array>
    <string name="charge_length_format" msgid="6941645744588690932">"<xliff:g id="ID_1">%1$s</xliff:g> më parë"</string>
    <string name="remaining_length_format" msgid="4310625772926171089">"<xliff:g id="ID_1">%1$s</xliff:g> të mbetura"</string>
    <string name="screen_zoom_summary_small" msgid="6050633151263074260">"I vogël"</string>
    <string name="screen_zoom_summary_default" msgid="1888865694033865408">"E parazgjedhur"</string>
    <string name="screen_zoom_summary_large" msgid="4706951482598978984">"I madh"</string>
    <string name="screen_zoom_summary_very_large" msgid="7317423942896999029">"Më i madh"</string>
    <string name="screen_zoom_summary_extremely_large" msgid="1438045624562358554">"Më i madhi"</string>
    <string name="screen_zoom_summary_custom" msgid="3468154096832912210">"I personalizuar (<xliff:g id="DENSITYDPI">%d</xliff:g>)"</string>
    <string name="content_description_menu_button" msgid="6254844309171779931">"Menyja"</string>
    <string name="retail_demo_reset_message" msgid="5392824901108195463">"Fut fjalëkalimin për të kryer rivendosje në gjendje fabrike në modalitetin e demonstrimit"</string>
    <string name="retail_demo_reset_next" msgid="3688129033843885362">"Përpara"</string>
    <string name="retail_demo_reset_title" msgid="1866911701095959800">"Kërkohet fjalëkalimi"</string>
    <string name="active_input_method_subtypes" msgid="4232680535471633046">"Metodat aktive të hyrjeve"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="4865195835541387040">"Përdor gjuhët e sistemit"</string>
    <string name="failed_to_open_app_settings_toast" msgid="764897252657692092">"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="6547562217880551450">"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="7845398276735021548">"Shënim: Pas një rinisjeje, ky aplikacion nuk mund të niset derisa të shkyçësh telefonin"</string>
    <string name="ims_reg_title" msgid="8197592958123671062">"Gjendja e regjistrimit të IMS-së"</string>
    <string name="ims_reg_status_registered" msgid="884916398194885457">"Regjistruar"</string>
    <string name="ims_reg_status_not_registered" msgid="2989287366045704694">"Paregjistruar"</string>
    <string name="status_unavailable" msgid="5279036186589861608">"Nuk ofrohet"</string>
    <string name="wifi_status_mac_randomized" msgid="466382542497832189">"Adresa MAC është e rastësishme"</string>
    <plurals name="wifi_tether_connected_summary" formatted="false" msgid="6317236306047306139">
      <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="5141801092071134235">"Më shumë kohë."</string>
    <string name="accessibility_manual_zen_less_time" msgid="6828877595848229965">"Më pak kohë."</string>
    <string name="cancel" msgid="5665114069455378395">"Anulo"</string>
    <string name="okay" msgid="949938843324579502">"Në rregull"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="6418297231575050426">"Aktivizo"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2760567063190790696">"Aktivizo \"Mos shqetëso\""</string>
    <string name="zen_mode_settings_summary_off" msgid="3832876036123504076">"Asnjëherë"</string>
    <string name="zen_interruption_level_priority" msgid="5392140786447823299">"Vetëm me prioritet"</string>
    <string name="zen_mode_and_condition" msgid="8877086090066332516">"<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="4146527909616457163">"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="245729928048586280">"Nuk do ta dëgjosh alarmin e radhës në <xliff:g id="WHEN">%1$s</xliff:g>"</string>
    <string name="alarm_template" msgid="3346777418136233330">"në <xliff:g id="WHEN">%1$s</xliff:g>"</string>
    <string name="alarm_template_far" msgid="6382760514842998629">"ditën <xliff:g id="WHEN">%1$s</xliff:g>"</string>
    <string name="zen_mode_duration_settings_title" msgid="1553451650289651489">"Kohëzgjatja"</string>
    <string name="zen_mode_duration_always_prompt_title" msgid="3212996860498119555">"Pyet çdo herë"</string>
    <string name="zen_mode_forever" msgid="3339224497605461291">"Deri sa ta çaktivizosh"</string>
    <string name="time_unit_just_now" msgid="3006134267292728099">"Pikërisht tani"</string>
    <string name="media_transfer_this_device_name" msgid="2716555073132169240">"Altoparlanti i telefonit"</string>
    <string name="profile_connect_timeout_subtext" msgid="4043408193005851761">"Problem me lidhjen. Fike dhe ndize përsëri pajisjen"</string>
    <string name="media_transfer_wired_device_name" msgid="4447880899964056007">"Pajisja audio me tel"</string>
    <string name="help_label" msgid="3528360748637781274">"Ndihma dhe komentet"</string>
    <string name="storage_category" msgid="2287342585424631813">"Hapësira ruajtëse"</string>
    <string name="shared_data_title" msgid="1017034836800864953">"Të dhënat e ndara"</string>
    <string name="shared_data_summary" msgid="5516326713822885652">"Shiko dhe modifiko të dhënat e ndara"</string>
    <string name="shared_data_no_blobs_text" msgid="3108114670341737434">"Nuk ka të dhëna të ndara për këtë përdorues."</string>
    <string name="shared_data_query_failure_text" msgid="3489828881998773687">"Ndodhi një gabim gjatë marrjes së të dhënave të ndara. Provo sërish."</string>
    <string name="blob_id_text" msgid="8680078988996308061">"ID-ja e të dhënave të ndara: <xliff:g id="BLOB_ID">%d</xliff:g>"</string>
    <string name="blob_expires_text" msgid="7882727111491739331">"Skadon më <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="shared_data_delete_failure_text" msgid="3842701391009628947">"Ndodhi një gabim gjatë fshirjes së të dhënave të ndara."</string>
    <string name="shared_data_no_accessors_dialog_text" msgid="8903738462570715315">"Nuk është marrë qira për këto të dhëna të ndara. Dëshiron ta fshish?"</string>
    <string name="accessor_info_title" msgid="8289823651512477787">"Aplikacionet që ndajnë të dhënat"</string>
    <string name="accessor_no_description_text" msgid="7510967452505591456">"Nuk jepet asnjë përshkrim nga aplikacioni."</string>
    <string name="accessor_expires_text" msgid="4625619273236786252">"Qiraja skadon në <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="delete_blob_text" msgid="2819192607255625697">"Fshi të dhënat e ndara"</string>
    <string name="delete_blob_confirmation_text" msgid="7807446938920827280">"Je i sigurt që dëshiron ta fshish këto të dhëna të ndara?"</string>
    <string name="user_add_user_item_summary" msgid="5748424612724703400">"Përdoruesit kanë aplikacionet dhe përmbajtjet e tyre"</string>
    <string name="user_add_profile_item_summary" msgid="5418602404308968028">"Mund të kufizosh qasjen në aplikacione dhe përmbajtje nga llogaria jote"</string>
    <string name="user_add_user_item_title" msgid="2394272381086965029">"Përdoruesi"</string>
    <string name="user_add_profile_item_title" msgid="3111051717414643029">"Profil i kufizuar"</string>
    <string name="user_add_user_title" msgid="5457079143694924885">"Të shtohet përdorues i ri?"</string>
    <string name="user_add_user_message_long" msgid="1527434966294733380">"Mund ta ndash këtë pajisje me persona të tjerë duke krijuar përdorues shtesë. Çdo përdorues ka hapësirën e vet, të cilën mund ta personalizojë me aplikacione, me imazhin e sfondit etj. Përdoruesit mund të rregullojnë po ashtu cilësimet e pajisjes, si Wi‑Fi, të cilat ndikojnë te të gjithë.\n\nKur shton një përdorues të ri, ai person duhet të konfigurojë hapësirën e vet.\n\nÇdo përdorues mund t\'i përditësojë aplikacionet për të gjithë përdoruesit e tjerë. Cilësimet e qasshmërisë dhe shërbimet mund të mos transferohen te përdoruesi i ri."</string>
    <string name="user_add_user_message_short" msgid="3295959985795716166">"Kur shton një përdorues të ri, ai person duhet të konfigurojë hapësirën e vet.\n\nÇdo përdorues mund t\'i përditësojë aplikacionet për të gjithë përdoruesit e tjerë."</string>
    <string name="user_setup_dialog_title" msgid="8037342066381939995">"Të konfig. përdoruesi tani?"</string>
    <string name="user_setup_dialog_message" msgid="269931619868102841">"Sigurohu që personi të jetë i gatshëm të marrë pajisjen dhe të caktojë hapësirën e vet"</string>
    <string name="user_setup_profile_dialog_message" msgid="4788197052296962620">"Të konfigurohet tani profili?"</string>
    <string name="user_setup_button_setup_now" msgid="1708269547187760639">"Konfiguro tani"</string>
    <string name="user_setup_button_setup_later" msgid="8712980133555493516">"Jo tani"</string>
    <string name="user_add_user_type_title" msgid="551279664052914497">"Shto"</string>
    <string name="user_new_user_name" msgid="60979820612818840">"Përdorues i ri"</string>
    <string name="user_new_profile_name" msgid="2405500423304678841">"Profili i ri"</string>
    <string name="user_info_settings_title" msgid="6351390762733279907">"Informacioni i përdoruesit"</string>
    <string name="profile_info_settings_title" msgid="105699672534365099">"Inform. i profilit"</string>
    <string name="user_need_lock_message" msgid="4311424336209509301">"Para se të mund të krijosh një profil të kufizuar, duhet të konfigurosh një kyçje të ekranit për të mbrojtur aplikacionet dhe të dhënat e tua personale."</string>
    <string name="user_set_lock_button" msgid="1427128184982594856">"Cakto kyçjen"</string>
    <string name="user_switch_to_user" msgid="6975428297154968543">"Kalo te <xliff:g id="USER_NAME">%s</xliff:g>"</string>
    <string name="guest_new_guest" msgid="3482026122932643557">"Shto të ftuar"</string>
    <string name="guest_exit_guest" msgid="5908239569510734136">"Hiq të ftuarin"</string>
    <string name="guest_nickname" msgid="6332276931583337261">"I ftuar"</string>
    <string name="cached_apps_freezer_device_default" msgid="2616594131750144342">"Parazgjedhja e pajisjes"</string>
    <string name="cached_apps_freezer_disabled" msgid="4816382260660472042">"Joaktiv"</string>
    <string name="cached_apps_freezer_enabled" msgid="8866703500183051546">"Aktiv"</string>
    <string name="cached_apps_freezer_reboot_dialog_text" msgid="695330563489230096">"Pajisja jote duhet të riniset që ky ndryshim të zbatohet. Rinise tani ose anuloje."</string>
    <string name="media_transfer_wired_usb_device_name" msgid="7699141088423210903">"Kufje me tela"</string>
</resources>
