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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Po"</string>
    <string name="no" msgid="6731231425810196216">"Jo"</string>
    <string name="create" msgid="3578857613172647409">"Krijo"</string>
    <string name="allow" msgid="3349662621170855910">"Lejo"</string>
    <string name="deny" msgid="6947806159746484865">"Refuzo"</string>
    <string name="dlg_close" msgid="7471087791340790015">"Mbyll"</string>
    <string name="dlg_switch" msgid="6243971420240639064">"Ndërro"</string>
    <string name="device_info_default" msgid="7847265875578739287">"E panjohur"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="other">Tani je <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> hapa larg të qenët programues.</item>
      <item quantity="one">Tani je <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> hap larg të qenët programues.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Tani je zhvillues!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nuk ka nevojë, ti je programues tashmë!"</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Rrjetet me valë"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Lidhjet"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Pajisja"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Personale"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Qasja"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sistemi"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Aktivizo lidhjen e të dhënave"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Çaktivizo lidhjen e të dhënave"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"VoLTE e përgatitur"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Telefonata me video u parapërgatit"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"Telefonata me Wifi u parapërgatit"</string>
    <string name="radio_info_radio_power" msgid="1208229437948820417">"Fuqia e radios së rrjetit celular"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Shiko librin e adresave të kartës SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Shiko numrat me telefonim të përzgjedhur"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Shiko numrat e telefonit të shërbimit"</string>
    <string name="radioInfo_menu_getPDP" msgid="8951059003824985976">"Merr listën PDP"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"Në shërbim"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Jashtë shërbimit"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Vetëm telefonata urgjence"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Radioja joaktive"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Jo në roaming"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Në gjendje joaktive"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Po bie zilja"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Telefonatë në vazhdim"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"I shkëputur"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Po lidhet"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"U lidh"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"I pezulluar"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"E panjohur"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"paketa"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajte"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Shkëput hapësirën për ruajtje të USB-së"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Shkëput kartën SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Spastro hapësirën për ruajtje të USB-së"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Spastroje kartën SD"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Pamja paraprake"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"Shiko paraprakisht, faqja <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> nga <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1690992332887488183">"Bëje tekstin në ekran më të vogël ose më të madh."</string>
    <string name="small_font" msgid="2295331917424072635">"E vogël"</string>
    <string name="medium_font" msgid="2068475425515133701">"Mesatar"</string>
    <string name="large_font" msgid="599055175160971446">"I madh"</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Zvogëlo"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Zmadho"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Teksti shembull"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Magjistari i mrekullueshëm i Ozit"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"Kapitulli 11: Qyteti i mrekullueshëm i smeraldtë i Ozit"</string>
    <string name="font_size_preview_text_body" msgid="1250552239682375643">"Edhe pse mbanin syzet e gjelbra mbi sy, në fillim Dorotia dhe miqtë e saj u verbuan nga shkëlqimi i qytetit të mrekullueshëm. Rrugët përshkoheshin nga vargje shtëpish të bukura, të gjitha të ndërtuara me mermer të gjelbër e të zbukuruara ngado me smeralde xixëlluese. Ata ecën në një trotuar të ndërtuar me të njëjtin mermer të gjelbër dhe aty ku bashkoheshin blloqet e mermerit kishte rreshta smeraldi, të vendosura afër njëri-tjetrit, dhe që shkëlqenin nën rrezet e diellit. Dritaret ishin me xham të gjelbër, madje edhe qielli mbi qytet kishte një nuancë të gjelbër dhe rrezet e diellit ishin të gjelbra. \n\nKishte shumë njerëz, burra, gra e fëmijë, që shëtisnin dhe të gjithë ishin të veshur me rroba të gjelbra dhe kishin lëkurë në të gjelbër. Ata i shikonin Dorotinë dhe shoqëruesit e saj të pazakontë me sy plot habi dhe fëmijët të gjithë vrapuan e u fshehën prapa nënave të tyre kur vunë re luanin; por askush nuk u foli një fjalë. Në rrugë kishte shumë dyqane dhe Dorotia vuri re se çdo gjë aty ishte e gjelbër. Aty shiteshin karamele të gjelbra dhe kokoshka të gjelbra, si dhe këpucë të gjelbra, kapela të gjelbra dhe rroba të gjelbra të çdo lloji. Në një dyqan një burrë po shiste limonada të gjelbra dhe kur blinin fëmijët, Dorotia arriti të shikonte se ata paguanin me monedha të gjelbra. \n\n||Nga sa dukej nuk kishte kuaj dhe asnjë kafshë të asnjë lloji; njerëzit i mbanin gjërat me karroca të vogla të gjelbra që i shtynin para vetes. Të gjithë dukeshin të lumtur e të kënaqur e të begatë."</string>
    <string name="font_size_save" msgid="3450855718056759095">"Në rregull"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Hapësira ruajtëse e USB-së"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Karta SD"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth-i"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"E dukshme për të gjitha pajisjet me \"Bluetooth\" në afërsi (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"E dukshme për të gjitha pajisjet me \"Bluetooth\" në afërsi"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Nuk është e dukshme te pajisjet e tjera me \"Bluetooth\""</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"E dukshme vetëm për pajisjet e çiftuara"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Koha e veprimit mbi dukshmërinë skadoi pa sukses"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Kyç formimin e numrit me zë"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Parandalo përdorimin e formuesit të numrit me Bluetooth kur ekrani është i kyçur."</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Pajisjet me Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Emri i pajisjes"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Cilësimet e pajisjes"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Cilësimet e profilit"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nuk është caktuar emër, po përdoret emri i llogarisë"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Skano për pajisje"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Riemërto këtë pajisje"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Riemërto"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Të shkëputet?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"Kjo do të mbyllë lidhjen tënde me:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nuk ke leje për të ndryshuar cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> është e dukshme për pajisjet në afërsi kur Cilësimet e Bluetooth-it janë të hapura."</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Të shkëputet <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Transmetimi"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Të çaktivizohet profili?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"Kjo do të çaktivizojë:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Nga:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Pajisje me \"Bluetooth\" e paemërtuar"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Po kërkon"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Nuk u gjet asnjë pajisje me Bluetooth në afërsi."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Kërkesë çiftimi me Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Kërkesa e çiftimit"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Trokit për ta çiftuar me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Shfaq skedarët e marrë"</string>
    <string name="device_picker" msgid="4978696506172252813">"Zgjidh pajisjen me Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Kërkesë lejeje për \"Bluetooth\""</string>
    <string name="bluetooth_ask_enablement" msgid="1712443355224737143">"Një aplikacion kërkon të AKTIVIZOJË \"Bluetooth-in\" për këtë pajisje."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Një aplikacion kërkon ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Një aplikacion kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me \"Bluetooth\" për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Një aplikacioni kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me \"Bluetooth\". Këtë mund ta ndryshosh më vonë te cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Një aplikacion kërkon ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_ask_start_broadcast" product="default" msgid="3535628155254187911">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë transmetimin me \"Bluetooth\" për të komunikuar me pajisje të tjera në afërsi. Këtë mund ta ndryshosh më vonë te cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default" msgid="8810858601242763295">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon të aktivizojë \"Bluetooth-in\" dhe transmetimin me \"Bluetooth\" për të komunikuar me pajisje të tjera në afërsi. Këtë mund ta ndryshosh më vonë te cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_broadcasting_explaination" product="default" msgid="4249322115655011799">"Kur ky funksion është i aktivizuar, telefoni yt mund të komunikojë me pajisjet e tjera në afërsi.\n\nTransmetimi përdor sinjalet e Bluetooth-it me energji të ulët."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Një aplikacion kërkon të aktivizojë Bluetooth-in dhe ta bëjë tabletin tënd të dukshëm ndaj pajisjeve të tjera për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Një aplikacion kërkon të aktivizojë Bluetooth-in dhe ta bëjë telefonin tënd të dukshëm ndaj pajisjeve të tjera për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Një aplikacion kërkon të aktivizojë \"Bluetooth-in\" dhe ta bëjë tabletin të dukshëm ndaj pajisjeve të tjera. Këtë mund ta ndryshosh më vonë te cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Një aplikacion kërkon të aktivizojë Bluetooth-in për ta bërë telefonin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth. Këtë mund ta ndryshosh më vonë te cilësimet e Bluetooth-it."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Po aktivizon Bluetooth-in…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Po çaktivizon \"Bluetooth-in\"…"</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Lidh automatikisht"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Kërkesa e lidhjes së Bluetooth-it"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Trokit për t\'u lidhur me \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Dëshiron që të lidhesh me \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Kërkesë për qasje në numërator"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s kërkon të ketë qasje te kontaktet dhe historiku i telefonatave. Të lejohet qasja për %2$s?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Mos pyet përsëri"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Mos pyet më"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Kërkesë për qasje në mesazhe"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s kërkon të ketë qasje te mesazhet e tua. Të lejohet qasja për %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Kërkesa për qasje në kartën SIM"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"Pajisja <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> dëshiron të ketë qasje në kartën tënde SIM. Dhënia e të drejtës për qasje në kartën SIM do të çaktivizojë lidhjen e të dhënave në pajisjen tënde gjatë kohëzgjatjes së lidhjes. Jepi qasje pajisjes <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Data dhe ora"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Zgjidh brezin orar"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Pamja paraprake:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Madhësia e shkrimit:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Dërgo <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Fillo <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Llogaria:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Përfaqësuesi"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Pastro"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Porta e përfaqësuesit"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Anashkalo përfaqësuesin për"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Restauro parazgjedhjet"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"U krye"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Emri pritës i përfaqësuesit"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Kujdes!"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"Në rregull"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Emri i pritësit që shkrove nuk është i vlefshëm."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Lista e përjashtimeve që shkrove nuk është e formatuar si duhet. Shkruaj një listë të ndarë me presje për domenet e përjashtuara."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Duhet të plotësosh fushën e portës."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Fusha e portës duhet të jetë boshe nëse fusha e pritësit është boshe."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Porta që shkrove nuk është e vlefshme."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Përfaqësuesi HTTP përdoret zakonisht nga shfletuesi. Ai mund të mos përdoret nga aplikacionet e tjera."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL-ja e përfaqësuesit: "</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Informacionet e vendndodhjes të rrjetit celular (e vjetruar):"</string>
    <string name="radio_info_neighboring_location_label" msgid="5766020323342985397">"Informacionet e rrjetit celular fqinj (e vjetruar):"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Shpejtësia e rifreskimit të informacioneve të rrjetit celular"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Të gjitha informacionet e matjes së rrjetit celular:"</string>
    <string name="radio_info_dcrtinfo_label" msgid="4062076024399431876">"Informacionet në kohë reale të lidhjes së të dhënave:"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Shërbimi i të dhënave:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Ridrejtimi i telefonatës:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"Numri i rivendosjeve të PPP-së që nga rifillimi:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Rrjeti aktual:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Të dhënat e marra:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Shërbimi zanor:"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Fuqia e sinjalit:"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"Statusi i telefonatës zanore:"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Të dhënat e dërguara:"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Mesazh në pritje:"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Numri i telefonit:"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Përzgjidh brezin e radios"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Lloji i rrjetit të zërit:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Lloji i rrjetit të të dhënave:"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Cakto llojin e preferuar të rrjetit:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Verifiko emrin e pritësit (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Verifiko emrin e pritësit (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"Testi i klientit HTTP:"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Ekzekuto testin e verifikimit \"ping\""</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Përditëso"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Rifresko"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"Ndrysho kontrollin e DNS-së"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informacion/cilësime specifike për OEM"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Cakto modalitetin e brezit të radios"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Po ngarkon listën e brezave…"</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Cakto"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Pa sukses"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Me sukses!"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Ndryshimet do të zbatohen kur të rilidhet kablloja e USB-së."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Aktivizo hapësirën ruajtëse masive të USB-së"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Bajte në total:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Hapësira ruajtëse e USB-së nuk është lidhur."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Nuk ka një kartë SD."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Bajtet e lira:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB-ja po përdoret si masive."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Karta SD po përdoret si pajisje e ruajtjes masive."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Hapësira USB mund të hiqet."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Tani nuk ka rrezik të heqësh kartën SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB-ja u hoq gjatë përdorimit!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Karta SD u hoq kur ishte ende në përdorim!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Bajtet e përdorura:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Po skanon hapësirën ruajtëse të USB-së për media…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Po skanon kartën SD për media…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Hapësira ruajtëse e USB-së e lidhur është vetëm për lexim."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Karta SD e lidhur vetëm për lexim."</string>
    <string name="skip_label" msgid="47510779345218297">"Kapërce"</string>
    <string name="next_label" msgid="4693520878012668114">"Përpara"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Gjuhët"</string>
    <string name="pref_title_lang_selection" msgid="2014920136978776034">"Preferencat për gjuhën"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Hiqe"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Shto gjuhë"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="other">Të hiqet gjuha e zgjedhur?</item>
      <item quantity="one">Të hiqet gjuha e zgjedhur?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Teksti do të shfaqet në një gjuhë tjetër."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Nuk mund të hiqen të gjitha gjuhët"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Mbaj të paktën një gjuhë të preferuar"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"Munsd të mos jetë i disponueshëm në disa aplikacione"</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Lëvize lart"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Lëvize poshtë"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Lëvize në krye"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Lëvize në fund"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Hiq gjuhën"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Zgjidh aktivitetin"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacioni i pajisjes"</string>
    <string name="display_label" msgid="8074070940506840792">"Ekrani"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informacion mbi tabletin"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacioni i telefonit"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Hapësira për ruajtje e USB-së"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Karta SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Cilësimet e përfaqësuesit"</string>
    <string name="cancel" msgid="6859253417269739139">"Anulo"</string>
    <string name="okay" msgid="1997666393121016642">"Në rregull"</string>
    <string name="forget" msgid="1400428660472591263">"Harro"</string>
    <string name="save" msgid="879993180139353333">"Ruaj"</string>
    <string name="done" msgid="6942539184162713160">"U krye!"</string>
    <string name="settings_label" msgid="1626402585530130914">"Cilësimet"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Cilësimet"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Shkurtorja e cilësimeve"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Modaliteti i aeroplanit"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Më shumë"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Wi-Fi dhe rrjetet"</string>
    <string name="radio_controls_summary" msgid="2837395036275123133">"Menaxho Wi‑Fi, Bluetooth, modalitetin \"në aeroplan\", rrjetet celulare dhe rrjetet VPN"</string>
    <string name="cellular_data_title" msgid="2525947635539415202">"Të dhënat celulare"</string>
    <string name="calls_title" msgid="3544471959217176768">"Telefonatat"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Mesazhe MMS"</string>
    <string name="cellular_data_summary" msgid="4575500999626276446">"Lejo përdorimin e të dhënave nëpërmjet rrjetit celular"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Lejo përdorimin e të dhënave kur je në roaming"</string>
    <string name="roaming" msgid="3596055926335478572">"Të dhënat në roaming"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Lidhu me shërbimet e të dhënave kur je në roaming"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Lidhu me shërbimet e të dhënave kur je në roaming"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Ke humbur lidhshmërinë e të dhënave sepse u largove nga rrjeti vendor me të dhënat e roaming-ut që çaktivizove."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Aktivizoje"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Mund të shkaktohen tarifa të larta."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Nëse lejon përdorim të dhënash gjatë kohës që je në roaming, mund të shkaktosh tarifa të konsiderueshme!\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë tablet."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Nëse lejon përdorim të dhënash gjatë kohës që je në roaming, mund të shkaktosh tarifa të konsiderueshme!\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë telefon."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Të lejohet shfrytëzimi i roaming-ut?"</string>
    <string name="networks" msgid="6333316876545927039">"Zgjedhja e operatorit"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Zgjidh një operator rrjeti"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Data dhe ora"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Vendos datën dhe orën"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Vendos datën, orën, brezin orar dhe formatet"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Data dhe ora, automatike"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Përdor orën e ofruar nga rrjeti"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Përdor orën e ofruar nga rrjeti"</string>
    <string name="zone_auto" msgid="334783869352026648">"Brezi orar, automatik"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Përdor brezin orar të ofruar nga rrjeti"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Përdor brezin orar të ofruar nga rrjeti"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"Formati \"24 orë\""</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Përdor formatin 24 orë"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Ora"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Vendos orën"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Brezi orar"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Brezi orar"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Data"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Vendos datën"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Rendit alfabetikisht"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Rendit sipas brezit orar"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Data"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Ora"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Kyçja automatike"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pas kalimit në gjendje gjumi"</string>
    <string name="lock_immediately_summary_with_exception" msgid="9119632173886172690">"Menjëherë pas gjumit, përveçse kur mbahet i shkyçur nga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pas kalimit në gjendje gjumi, përveçse kur mbahet i shkyçur nga <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Shfaq informacionin e zotëruesit në ekranin e kyçjes"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Mesazhi i ekranit të kyçjes"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Aktivizo miniapl."</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Çaktivizuar nga administratori"</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Asnjë"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g> / <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"P.sh., pajisja Android e Admirit."</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Informacioni i përdoruesit"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Shfaq informacionin e profilit në ekranin e kyçjes"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Inform. i profilit"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Llogaritë"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Vendndodhja"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Llogaritë"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Siguria"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Cakto \"Vendndodhjen time\", shkyçjen e ekranit, kyçjen e kartës SIM, kyçjen e hapësirës për ruajtjen e kredencialeve"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Cakto \"Vendndodhja ime\", shkyçjen e ekranit, kyçjen e hapësirës ruajtëse të kredencialeve"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Fjalëkalimet"</string>
    <string name="disabled_by_administrator_summary" msgid="5989801404248162477">"Çaktivizuar nga administratori"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Gjurma e gishtit"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Menaxho gjurm. gishtit"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Përdor gjurmën për"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Shto gjurmë gishti"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"kyçja e ekranit"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> gjurmë gishti u konfiguruan</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> gjurmë gishti u konfigurua</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Shkyçe me gjurmën e gishtit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Thjesht prek te sensori i gjurmës së gishtit për të shkyçur telefonin, për të autorizuar blerjet ose për t\'u identifikuar tek aplikacionet. Trego kujdes se gjurmët e kujt shton. Çdo gjurmë gishti e shtuar do të mund t\'i kryejë këto gjëra. \n\nShënim: Gjurma jote e gishtit mund të jetë më pak e sigurt se një motiv ose një kod PIN i fortë."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="3635924459027832861">"Thjesht prek te sensori i gjurmës së gishtit për të shkyçur telefonin, për të autorizuar blerjet ose për t\'u identifikuar tek aplikacionet. Trego kujdes se gjurmët e kujt shton. Çdo gjurmë gishti e shtuar do të mund t\'i kryejë këto gjëra.\n\nShënim: Gjurma jote e gishtit mund të jetë më pak e sigurt se një motiv ose një kod PIN i fortë."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Anulo"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Vazhdo"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Kapërceje"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="8386444182056861429">"Shto gjurmë gishti"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="7234486440384881699">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do të mund t\'i parandalosh të tjerët të përdorin këtë tablet nëse ai humb, të vidhet ose fshihet."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="3519190003101280912">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund t\'i parandalosh të tjerët ta përdorin këtë pajisje nëse nëse e humb atë ose nëse të vidhet."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="417315011140961">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund t\'i parandalosh të tjerët ta përdorin këtë telefon nëse e humb atë ose nëse të vidhet."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="8783499872534165700">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund t\'i parandalosh të tjerët ta përdorin këtë tablet nëse e humb atë ose nëse të vidhet."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="3120512940873907578">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund t\'i parandalosh të tjerët ta përdorin këtë pajisje nëse e humb atë ose nëse të vidhet."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3589945558504439395">"Funksionet e mbrojtjes së pajisjes nuk do të aktivizohen. Ti nuk do mund t\'i parandalosh të tjerët ta përdorin këtë telefon nëse e humb atë ose nëse të vidhet."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Kapërceje gjithsesi"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Kthehu prapa"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="5877265753699187149">"Gjej sensorin"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="1959655161889313661">"Gjej sensorin e gjurmës së gishtit në pjesën e pasme të telefonit."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustrim me pajisjen dhe vendndodhjen e sensorit të gjurmës së gjishtit"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Emri"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"Në rregull"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Fshi"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="951888937749663602">"Fillojmë"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Vendose gishtin mbi sensor dhe ngrije pasi të ndjesh një dridhje"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="8556556992897619044">"Vazhdo"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="4232813847507193627">"Lëvize pak gishtin për të shtuar të gjitha pjesët e ndryshme të gishtit tënd"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="4798692662828257300">"Gjurma u shtua!"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="835496875787664316">"Sa herë që shikon këtë ikonë, mund të përdorësh gjurmën e gishtit për identifikim ose për të autorizuar një blerje."</string>
    <string name="setup_fingerprint_enroll_finish_message" msgid="7234264291957984004">"Mjafton të prekësh sensorin e gjurmës së gishtit për të zgjuar dhe shkyçur pajisjen."</string>
    <string name="setup_fingerprint_enroll_finish_message_secondary" msgid="7104778933406207968">"Kur e sheh këtë ikonë, mund të autorizosh gjithashtu blerjet ose të identifikohesh në aplikacione."</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"Kapërce konfigurimin e gjurmës së gishtit?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"Ke zgjedhur që të përdorësh gjurmën e gishtit si një mënyrë për ta shkyçur telefonin. Nëse e kapërcen teni, do të duhet ta konfigurosh këtë më vonë. Konfigurimi do të zgjasë vetëm afro një minutë."</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Konfiguro kyçjen e ekranit"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"U krye"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Jo, sensori nuk është ai"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="5053971232594165142">"Përdor sensorin e gjurmës së gishtit në pajisje."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"Regjistrimi nuk përfundoi"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"U arrit kufiri kohor për regjistrimin e gjurmës së gishtit. Provo përsëri."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"Regjistrimi i gjurmës së gishtit nuk funksionoi. Provo përsëri ose përdor një gisht tjetër."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Shto një tjetër"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Përpara"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Përveç shkyçjes së telefonit, gjurmën e gishtit mund ta përdorësh edhe për të autorizuar blerjet dhe qasjen në aplikacione. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7007548031540826618">"Opsioni i kyçjes së ekranit është çaktivizuar. Kontakto me administratorin e organizatës tënde për të mësuar më shumë. "<annotation id="admin_details">"Më shumë detaje"</annotation>\n\n"Mund të vazhdosh të përdorësh gjurmën e gishtit për të autorizuar blerjet dhe për qasje në aplikacion. "<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Ngrije gishtin dhe më pas preke përsëri sensorin"</string>
    <string name="setup_fingerprint_enroll_finish_message" msgid="4132164775128798343">"Kurdo që ta shohësh këtë ikonë, mund të përdorësh gjurmën e gishtave."</string>
    <string name="setup_fingerprint_enroll_finish_secondary_message" msgid="3734962461534384882">"Për të ndryshuar cilësimet, shko te Cilësimet, Siguria dhe Gjurma e Gishtave."</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Mund të shtosh deri në <xliff:g id="COUNT">%d</xliff:g> gjurma të gishtave"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Të hiqen të gjitha gjurmët e gishtave?"</string>
    <string name="fingerprint_last_delete_message" msgid="8318926239554839722">"Nuk do të jesh në gjendje të përdorësh gjurmët e gishtave për të shkyçur telefonin, për të autorizuar blerjet ose për t\'u identifikuar në aplikacione me to."</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="8840100810725902159">"Nuk do të jesh në gjendje të përdorësh gjurmët e gishtave për të shkyçur profilin tënd të punës, për të autorizuar blerjet ose për t\'u identifikuar në aplikacionet e punës."</string>
    <string name="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Po, hiqe"</string>
    <string name="confirm_fingerprint_icon_content_description" msgid="5255544532157079096">"Përdor gjurmën e gishtit për të vazhduar."</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Enkriptimi"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Enkripto tabletin"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Enkripto telefonin"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"I enkriptuar"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Mund të enkriptosh llogaritë e tua, cilësimet, aplikacionet e shkarkuara dhe të dhënat e tyre, klipet \"media\" (muzikë e fotografi) si dhe skedarë të tjerë. Pasi të kesh enkriptuar tabletin, do të të nevojitet një kod PIN numerik apo fjalëkalim që të shkyçësh ekranin për ta deshifruar atë çdo herë që e ndez. E vetmja mënyrë tjetër për të deshifruar tabletin është rivendosja në gjendje fabrike, duke spastruar të gjitha të dhënat.\n\nEnkriptimi zgjat një orë ose më shumë. Kur të fillosh, sigurohu të kesh baterinë e ngarkuar dhe ta mbash tabletin në prizë gjatë gjithë procesit. Nëse e ndërpret, do të humbësh disa nga të dhënat ose të gjitha."</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Mund të enkriptosh llogaritë e tua, cilësimet, aplikacionet e shkarkuara dhe të dhënat e tyre, klipet \"media\" (muzikë e fotografi) si dhe skedarë të tjerë. Pasi ta kesh enkriptuar telefonin, do të të nevojitet një kod PIN numerik apo fjalëkalim që të shkyçësh ekranin e për ta deshifruar atë çdo herë që e ndez. E vetmja mënyrë tjetër për të deshifruar telefonin është rivendosja në gjendje fabrike, duke spastruar të gjitha të dhënat.\n\nEnkriptimi zgjat një orë ose më shumë. Kur të fillosh, sigurohu të kesh baterinë e ngarkuar dhe ta mbash telefonin në prizë gjatë gjithë procesit. Nëse e ndërpret, do të humbësh disa nga të dhënat ose të gjitha."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Enkripto tabletin"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Enkripto telefonin"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Ngarko baterinë dhe provo përsëri."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Vëre ngarkuesin në prizë dhe provo përsëri."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Nuk ka një kod PIN ose fjalëkalim të ekranit të kyçjes"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Duhet të caktosh një PIN të ekranit të kyçjes ose një fjalëkalim para se të mund të nisësh enkriptimin."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Të enkriptohet?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Operacioni i enkriptimit është i pakthyeshëm dhe nëse e ndërpret, do të humbësh të dhënat. Enkriptimi zgjat një orë ose më shumë, kohë gjatë të cilës tableti do të riniset disa herë."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Operacioni i enkriptimit është i pakthyeshëm dhe nëse e ndërpret, do të humbësh të dhënat. Enkriptimi zgjat një orë ose më shumë, kohë gjatë të cilës telefoni do të riniset disa herë."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Po enkripton"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Prit ndërsa tableti po enkriptohet. <xliff:g id="PERCENT">^1</xliff:g>% të përfunduara."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Prit ndërsa telefoni po enkriptohet. <xliff:g id="PERCENT">^1</xliff:g>% e përfunduar."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Prit ndërsa tableti enkriptohet. Koha e mbetur: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Prit ndërsa telefoni po enkriptohet. Koha e mbetur: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Për të shkyçur tabletin, fike dhe pastaj ndize."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Për të shkyçur telefonin, fike dhe më pas ndize."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Paralajmërim! Pajisja jote do të fshihet pas <xliff:g id="COUNT">^1</xliff:g> përpjekjeve të tjera të dështuara për shkyçje!"</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Shkruaj fjalëkalimin tënd"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Enkriptimi ishte i pasuksesshëm"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Enkriptimi u ndërpre dhe nuk mund të përfundojë. Si rezultat, nuk është më e mundur qasja te të dhënat në tablet. \n\nPër të rifilluar përdorimin e tabletit, duhet të kryesh një rivendosje në gjendje fabrike. Kur ta konfigurosh tabletin pas rivendosjes, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Enkriptimi u ndërpre dhe nuk mund të përfundojë. Si rezultat, nuk është më e mundur qasja te të dhënat në telefon. \n\nPër të rifilluar përdorimin e telefonit, duhet të kryesh një rivendosje në gjendje fabrike. Kur ta konfigurosh telefonin pas rivendosjes, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dekriptimi ishte i pasuksesshëm"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Fjalëkalimi që fute është i saktë, por fatkeqësisht të dhënat e tua janë të dëmtuara. \n\nPër të rifilluar përdorimin e tabletit, duhet të kryesh një vendosje në gjendje fabrike. Pas kësaj, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Fjalëkalimi që fute është i saktë, por fatkeqësisht të dhënat e tua janë të dëmtuara. \n\nPër të rifilluar përdorimin e telefonit, duhet të kryesh një vendosje në gjendje fabrike. Pas kësaj, do të kesh mundësinë për të restauruar çdo të dhënë që është rezervuar në llogarinë e Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Ndërro metodën e hyrjes"</string>
    <string name="suggested_lock_settings_title" msgid="8971630898700461034">"Vendos kyçjen e ekranit"</string>
    <string name="suggested_lock_settings_summary" msgid="8778462376012231110">"Mbroje pajisjen tënde"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3655973509619012084">"Përdor gjurmën e gishtit"</string>
    <string name="suggested_fingerprint_lock_settings_summary" msgid="2149569133725273864">"Shkyçe me gjurmën e gishtit"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Zgjidh kyçjen e ekranit"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Zgjidh kyçjen e punës"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Mbroje tabletin tënd"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Mbroje pajisjen tënde"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Mbroje telefonin tënd"</string>
    <string name="setup_lock_settings_picker_fingerprint_message" msgid="5585650064305600578">"Për më shumë siguri, konfiguro një kyçje rezervë për ekranin."</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Parandalo që të tjerët ta përdorin këtë tablet pa lejen tënde duke aktivizuar funksionet e mbrojtjes së pajisjes. Zgjidh kyçjen e ekranit që dëshiron të përdorësh."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Parandalo që të tjerët ta përdorin këtë pajisje pa lejen tënde duke aktivizuar funksionet e mbrojtjes së pajisjes. Zgjidh kyçjen e ekranit që dëshiron të përdorësh."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Parandalo që të tjerët ta përdorin këtë telefon pa lejen tënde duke aktivizuar funksionet e mbrojtjes së pajisjes. Zgjidh kyçjen e ekranit që dëshiron të përdorësh."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Zgjidh mënyrën rezervë të kyçjes së ekranit"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Kyçja e ekranit"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Kyçja e profilit të punës"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Ndrysho ekranin e kyçjes"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Ndrysho ose çaktivizo sigurinë e motivit, kodit PIN ose fjalëkalimit"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Zgjidh një metodë për të kyçur ekranin"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Asnjë"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Me rrëshqitje"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Pa siguri"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Me motiv"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Siguria mesatare"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"Me kod PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Siguri mesatare deri në të lartë"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Me fjalëkalim"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Siguri e lartë"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Jo tani"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Kyçja aktuale e ekranit"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Gjurma e gishtit + Motivi"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Gjurma e gishtit + Kodi PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Gjurma e gishtit + Fjalëkalimi"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Çaktivizuar nga admin., enkriptimi ose kredenciale"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Asnjë"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Me rrëshqitje"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Motivi"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"Kodi PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Fjalëkalimi"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Pasi të kesh konfiguruar një kyçje të ekranit, mund të konfigurosh po ashtu gjurmën e gishtit te Cilësimet &gt; Siguria."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Çakt. kyçjen e ekranit"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Të hiqet mbrojtja e pajisjes?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"Të hiqet mbrojtja e profilit?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa motivin tënd."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="8212242533942400457">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa motivin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kodin tënd PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="875669051899437197">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kodin tënd PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa fjalëkalimin tënd."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="2228159168587170445">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa fjalëkalimin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kyçjen tënde të ekranit."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6363091330281670692">"Funksionet e mbrojtjes së pajisjes nuk do të funksionojnë pa kyçjen tënde të ekranit.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga kjo pajisje dhe nuk do të jesh në gjendje të shkyçësh telefonin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa motivin tënd."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="3675154828957224316">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa motivin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh profilin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa kodin tënd PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4879321153584598940">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa kodin tënd PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh profilin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa fjalëkalimin tënd."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="3527188316958917839">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa fjalëkalimin tënd.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh profilin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa kyçjen tënde të ekranit."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="1962204059377724158">"Funksionet e mbrojtjes së profilit nuk do të funksionojnë pa kyçjen tënde të ekranit.<xliff:g id="EMPTY_LINE">

</xliff:g>Edhe gjurmët e gishtave të ruajtura do të hiqen nga ky profil dhe nuk do të jesh në gjendje të shkyçësh profilin, të autorizosh blerjet apo të identifikohesh në aplikacione me to.\""</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Po, hiqe"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Ndrysho motivin e shkyçjes"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Ndrysho kodin PIN"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Ndrysho fjalk. shkyçjes"</string>
    <string name="lock_profile_wipe_attempts" msgid="1216193652369039672">"Provo sërish. Përpjekja <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> nga <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_profile_wipe_warning_title" msgid="2961600792367265036">"Përpjekja e fundit"</string>
    <string name="lock_profile_wipe_warning_content_pattern" msgid="8978031996247660921">"Nëse fut motivin e punës gabimisht gjatë kësaj përpjekjeje, profili i punës dhe të dhënat shoqëruese do të hiqeni nga kjo pajisje."</string>
    <string name="lock_profile_wipe_warning_content_pin" msgid="7697973618542377880">"Nëse fut numrin PIN të punës gabimisht gjatë kësaj përpjekjeje, profili i punës dhe të dhënat shoqëruese do të hiqeni nga kjo pajisje."</string>
    <string name="lock_profile_wipe_warning_content_password" msgid="450695588340509349">"Nëse fut fjalëkalimin e punës gabimisht gjatë kësaj përpjekjeje, profili i punës dhe të dhënat shoqëruese do të hiqeni nga kjo pajisje."</string>
    <string name="lock_profile_wipe_content" msgid="2150455386921347628">"Shumë përpjekje të pasakta. Profili i punës dhe të dhënat shoqëruese do të hiqeni nga kjo pajisje."</string>
    <string name="lock_profile_wipe_dismiss" msgid="5118293266264141442">"Largoje"</string>
    <string name="lockpassword_password_too_short" msgid="2691590536362441127">"Duhet të jetë të paktën %d karaktere"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"Kodi PIN duhet të ketë të paktën %d shifra"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Vazhdo"</string>
    <string name="lockpassword_password_too_long" msgid="4520363269062591833">"Duhet të jetë më pak se <xliff:g id="NUMBER">%d</xliff:g> karaktere."</string>
    <string name="lockpassword_pin_too_long" msgid="4010052843684165845">"Duhet të jetë më pak se <xliff:g id="NUMBER">%d</xliff:g> shifra."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="5537252833154289817">"Duhet të përmbajë vetëm shifra 0-9."</string>
    <string name="lockpassword_pin_recently_used" msgid="214840704635573454">"Administratori i pajisjes nuk e lejon përdorimin e një kodi PIN të përdorur së fundi."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"Kjo nuk mund të përfshijë një karakter të pavlefshëm"</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Duhet të përmbajë të paktën një germë"</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Duhet të përmbajë të paktën një shifër"</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Duhet të përmbajë të paktën një simbol"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="3121545900151618401">
      <item quantity="other">Duhet të përmbajë të paktën %d germa</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 germë</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="5415008859853535577">
      <item quantity="other">Duhet të përmbajë të paktën %d germa të vogla</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 germë të vogël</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="1452012183267855761">
      <item quantity="other">Duhet të përmbajë të paktën %d germa të mëdha</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 germë të madhe</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="5536275490534483515">
      <item quantity="other">Duhet të përmbajë të paktën %d shifra numerike</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 shifër numerike</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="5132998285340017795">
      <item quantity="other">Duhet të përmbajë të paktën %d simbole të veçanta</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 simbol të veçantë</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="2778958281865593579">
      <item quantity="other">Duhet të përmbajë të paktën %d karaktere që nuk janë germa</item>
      <item quantity="one">Duhet të përmbajë të paktën 1 karakter që nuk është germë</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="4687102591995446860">"Administratori i pajisjes nuk e lejon përdorimin e një fjalëkalimi të përdorur së fundi."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="6830610582179569631">"Ndalohet një sekuencë në rritje, në zbritje ose me përsëritje të shifrave"</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"Në rregull"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Anulo"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Anulo"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Përpara"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Konfigurimi përfundoi."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Administrimi i pajisjes"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Administratorët e pajisjes"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Shiko ose çaktivizo administratorët e pajisjes"</string>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Agjentët e besuar"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Për ta përdorur, në fillim cakto një kyçje ekrani"</string>
    <string name="manage_trust_agents_summary" msgid="6804319935640148441">"Shiko ose çaktivizo agjentët e besuar"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth-i"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Aktivizo \"Bluetooth-in\""</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth-i"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth-i"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Menaxho lidhjet, cakto emrin e pajisjes dhe zbulueshmërinë"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Të çiftohet me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Kodi i çiftimit të \"bluetooth-it\""</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Shkruaj kodin e çiftimit, pastaj shtyp \"Kthehu\" ose \"Hyr\""</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Kodi PIN përmban shkronja ose simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Zakonisht 0000 ose 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Duhet të ketë 16 shifra"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Mund të duhet gjithashtu ta shkruash këtë kod PIN në pajisjen tjetër."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Mund të duhet gjithashtu ta shkruash këtë kod në pajisjen tjetër."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Për ta çiftuar me:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;sigurohu që të tregojë këtë kod:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Nga:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Të çiftohet me këtë pajisje?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Për ta çiftuar me:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Shkruaj në të:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g> dhe më pas shtyp Kthehu ose Hyr."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="2277931851483023208">"Lejo që <xliff:g id="DEVICE_NAME">%1$s</xliff:g> të ketë qasje te kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"Nuk mundi të lidhej me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Skano për pajisje"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Rifresko"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Po kërkon..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Cilësimet e pajisjes"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Pajisja e çiftuar"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Emri"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Lidhje me internet"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Tastiera"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontaktet dhe historiku i telefonatave"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Të çiftohet me këtë pajisje?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Të ndahet numëratori telefonik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> kërkon të ketë qasje te kontaktet dhe historiku i telefonatave."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> kërkon të çiftohet me Bluetooth. Kur të lidhet, pajisja do të ketë qasje te kontaktet e tua dhe historiku i telefonatave."</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Pajisjet e çiftuara"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Pajisjet që ofrohen"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nuk ofrohet asnjë pajisje"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Lidh"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Shkëput"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Ҫifto dhe lidh"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Hiq nga çiftimi"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Shkëput dhe hiq nga çiftimi"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Opsionet..."</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Të përparuara"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Cilësimet e përparuara të Bluetooth-it"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Kur Bluetooth-i është i aktivizuar, pajisja jote mund të komunikojë me pajisjet e tjera me Bluetooth në afërsi."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Për të përmirësuar saktësinë e vendndodhjes, aplikacionet dhe shërbimet e sistemit mund t\'i zbulojnë akoma pajisjet me Bluetooth. Këtë mund ta ndryshosh te <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>cilësimet e skanimit<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Lidhu me…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga audioja e medias."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga audioja \"pa duar\"."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga pajisja e hyrjes."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Qasja në internet përmes <xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="1262792320446274407">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga ndarja e lidhjes së internetit të këtij tableti."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5700332050175684571">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> do të shkëputet nga ndarja e lidhjes së internetit të këtij telefoni."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Pajisja me Bluetooth e çiftuar"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Lidh"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Lidhu me pajisjen me Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Përdore për"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Riemërto"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Lejo transferimet e skedarëve hyrës"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Lidhur me pajisjen për qasje në internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Po ndan lidhjen lokale të internetit me pajisjen"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Cilësimet e stacionit"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Përdor stacionin për audion"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Si altoparlant"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Për muzikë dhe media"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Kujto cilësimet"</string>
    <string name="wifi_assistant_title" msgid="2553267316621598101">"Ndihmësi i Wi-Fi"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Transmetimi"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Aktivizo shfaqjen e rrjetit valor"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Nuk u gjet asnjë pajisje në afërsi."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Po lidhet"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Të lidhura"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Në përdorim"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Nuk ofrohet"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Shfaq cilësimet"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Opsionet e shfaqjes së Wi-Fi"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Harro"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"U krye!"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Emri"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="link_speed" msgid="8896664974117585555">"%1$d Mbps"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Lejo shkëmbimin e të dhënave kur tableti prek një tjetër pajisje"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Lejo shkëmbimin e të dhënave kur telefoni prek një tjetër pajisje"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"Aktivizo NFC-në"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"Të dhënat e shkëmbimit NFC mes kësaj pajisjeje dhe pajisjeve ose objektivave të tjera në afërsi, siç janë terminalet e pagesave, lexuesit e qasjes dhe reklamat apo etiketat interaktive."</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Dërgimi me rreze i Androidit"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Gati për të transmetuar përmbajtjen e aplikacionit përmes NFC-së"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Çaktivizuar"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Nuk ofrohet sepse NFC-ja është e çaktivizuar"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Dërgimi me rreze i Androidit"</string>
    <string name="android_beam_explained" msgid="1828555626055290684">"Kur ky funksion është i aktivizuar, mund të transmetosh përmbajtjet e aplikacioneve te një pajisje tjetër me aftësinë e NFC-së duke i mbajtur pajisjet afër. Për shembull, mund të transmetosh faqet e shfletuesit, videot në YouTube, kontaktet e më shumë.\n\nThjesht afroji pajisjet me njëra-tjetrën (zakonisht nga pjesa e pasme) dhe më pas trokit tek ekrani. Aplikacioni përcakton se çfarë do të transmetohet."</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Aktivizo Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi‑Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Cilësimet e Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi‑Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Cakto dhe menaxho zonat e qasjes të rrjetit me valë"</string>
    <string name="wifi_setup_wizard_title" msgid="7873622558088429710">"Zgjidh rrjetin Wi-Fi"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Zgjidh Wi‑Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Po aktivizon Wi‑Fi…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Po çaktivizon Wi‑Fi…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Gabim"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"Brezi 5 GHz nuk ofrohet në këtë vend"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Në modalitetin e aeroplanit"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Njoftimi për rrjetin"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3716818008370391253">"Njofto sa herë që ofrohet ndonjë rrjet publik"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Shmang lidhjet e dobëta"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2784135142239546291">"Mos e përdor një rrjet Wi‑Fi nëse nuk ka lidhje të mirë interneti"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"Përdor vetëm rrjete që kanë lidhje të mirë interneti"</string>
    <string name="wifi_automatically_connect_title" msgid="7950640291510621742">"Përdor automatikisht Wi-Fi të hapur"</string>
    <string name="wifi_automatically_connect_summary" msgid="6722194413023965902">"Lejo një ndihmës Wi‑Fi të lidhet automatikisht për të hapur rrjetet me cilësi të lartë"</string>
    <string name="wifi_select_assistant_dialog_title" msgid="4014645210955009439">"Zgjidh ndihmësin"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instalo certifikatat"</string>
    <string name="wifi_scan_notify_text" msgid="5593805423071186757">"Për të përmirësuar saktësinë e vendndodhjes, aplikacionet dhe shërbimet e sistemit mund të skanojnë akoma për rrjetet Wi-Fi. Këtë mund ta ndryshosh te <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>cilësimet e skanimit<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Mos e shfaq përsëri"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Wi-Fi aktiv kur fiket ekrani"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi-Fi gjatë qendrimit në gjendje gjumi"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Kishte një problem me ndryshimin e cilësimit"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Përmirëso efikasitetin"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizimi i Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimizo përdorimin e baterisë kur Wi‑Fi është aktiv"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Kufizo baterinë në Wi-Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="1410499115509796174">"Kalo te të dhënat celulare nëse Wi‑Fi humbet qasjen në internet."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8741291033791891668">"Kalo automatikisht te të dhënat celulare"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="2641527693037426430">"Përdor të dhënat celulare kur Wi-Fi nuk ka qasje në internet. Mund të zbatohet përdorimi i të dhënave."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Shto një rrjet"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Rrjetet Wi‑Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Butoni me shtypje WPS"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Opsione të tjera"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Futja e kodit PIN të WPS-së"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi-Fi Direkt"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Skano"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Të përparuara"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Konfiguro"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Lidhu me rrjetin"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Kujto rrjetin"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Harro rrjetin"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modifiko rrjetin"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Shkruaj në etiketën NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Për të parë rrjetet që ofrohen, aktivizo Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Po kërkon për rrjete Wi‑Fi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Nuk ke leje të ndryshosh rrjetin Wi-Fi."</string>
    <string name="wifi_other_network" msgid="1484433183857764750">"Shto një rrjet tjetër"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Më shumë"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Konfigurimi automatik (WPS)"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Opsionet e përparuara"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Konfigurimi i mbrojtur i Wi‑Fi"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Po nis WPS..."</string>
    <string name="wifi_wps_onstart_pbc" msgid="817003360936932340">"Shtyp butonin \"Konfigurimi i mbrojtur i Wi‑Fi\" në rrugëzuesin tënd. Ai mund të quhet \"WPS\" ose mund të përmbajë këtë simbol:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Fut kodin PIN <xliff:g id="NUMBER">%1$s</xliff:g> në rrugëzuesin e Wi‑Fi. Konfigurimi mund të zgjasë deri në dy minuta për të përfunduar."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"WPS pati sukses. Po lidhet me rrjetin..."</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"U lidh me rrjetin Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"WPS është tashmë në proces dhe mund të zgjasë deri në dy minuta për ta përfunduar"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"WPS-ja dështoi. Provo përsëri pas disa minutash."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Cilësimi i sigurisë së rrugëzuesit pa tel (WEP) nuk mbështetet"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Cilësimi i sigurisë së rrugëzuesit pa tel (TKIP) nuk mbështetet"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Verifikimi dështoi, provo përsëri."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"U zbulua një sesion tjetër i WPS-së. Provo përsëri për disa minuta."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Emri i rrjetit"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Fut SSID-në"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Siguria"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Fuqia e sinjalit"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Statusi"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Shpejtësia e lidhjes"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekuenca"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Adresa e IP-së"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"U ruajt me"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"Kredencialet e <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Metoda EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Vërtetimi i Fazës 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certifikata CA"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Domeni"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certifikata e përdoruesit"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identiteti"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Identitet anonim"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Fjalëkalimi"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Shfaq fjalëkalimin"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Zgjidh bandën AP"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Bandë 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8137061170937978040">"Bandë 5 GHz"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Cilësimet e IP-së"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Ndaje me përdoruesit e tjerë të pajisjes"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(i pandryshuar)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Zgjidh"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(U shtuan shumë certifikata)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Përdor certifikatat e sistemit"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Mos e ofro"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Mos e mirato"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Nuk u specifikua asnjë certifikatë. Lidhja jote nuk do të jetë private."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Duhet të specifikohet një domen."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"Ofrohet WPS"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (Ofrohet WPS)"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Fut fjalëkalimin e rrjetit"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Për të përmirësuar saktësinë e vendndodhjes dhe për qëllime të tjera, <xliff:g id="APP_NAME">%1$s</xliff:g> dëshiron të aktivizojë skanimin e rrjetit, edhe kur Wi-Fi është joaktiv.\n\nTë lejohet kjo për të gjitha aplikacionet që dëshirojnë të skanojnë?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Për ta çaktivizuar këtë, shko te \"Të përparuara\" në menynë e tejkalimit."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Lejo"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Refuzo"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Dëshiron të identifikohesh për t\'u lidhur?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> kërkon që të identifikohesh në linjë para se të lidhesh me rrjetin."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"LIDHE"</string>
    <string name="no_internet_access_text" msgid="7133561752896706392">"Ky rrjet nuk ka qasje në internet. Qëndro i lidhur?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Mos pyet përsëri për këtë rrjet"</string>
    <string name="lost_internet_access_title" msgid="6228530645663584505">"Wi-Fi nuk është i lidhur me internetin"</string>
    <string name="lost_internet_access_text" msgid="1676124057345106398">"Mund të kalosh në rrjetin celular sa herë që Wi‑Fi ka lidhje të keqe. Mund të zbatohen tarifa për përdorimin e të dhënave."</string>
    <string name="lost_internet_access_switch" msgid="1980357004205108781">"Kalo në celular"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Qëndro në Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Kurrë mos e trego përsëri"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Lidh"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Lidhja me rrjetin dështoi"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Harro"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Dështoi në harrimin e rrjetit"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Ruaj"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Dështoi në ruajtjen e rrjetit"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Anulo"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Kapërceje"</string>
    <string name="wifi_dont_skip" msgid="3615535136327231588">"Kthehu prapa"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="6761689889733331124">"PARALAJMËRIM! Nëse kapërcen Wi-Fi, tableti do të përdorë vetëm të dhëna celulare për shkarkimet dhe përditësimet fillestare. Për të shmangur tarifat e mundshme për të dhënat, lidhu me Wi-Fi."</string>
    <string name="wifi_skipped_message" product="device" msgid="1385490367826852775">"PARALAJMËRIM! Nëse kapërcen Wi-Fi, pajisja do të përdorë vetëm të dhëna celulare për shkarkimet dhe përditësimet fillestare. Për të shmangur tarifat e mundshme për të dhënat, lidhu me Wi-Fi."</string>
    <string name="wifi_skipped_message" product="default" msgid="6084295135297772350">"PARALAJMËRIM! Nëse kapërcen Wi-Fi, telefoni do të përdorë vetëm të dhëna celulare për shkarkimet dhe përditësimet fillestare. Për të shmangur tarifat e mundshme për të dhënat, lidhu me Wi-Fi."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="6324917391996718760">"Nëse kapërcen lidhjen Wi‑Fi:\n\n"<li>"Tableti nuk do të ketë lidhje me internetin."</li>\n\n<li>"Nuk do të marrësh përditësime të softuerëve derisa të lidhesh me internetin."</li>\n\n<li>"Nuk mund të aktivizosh funksionet e mbrojtjes së pajisjes në këtë moment."</li></string>
    <string name="wifi_and_mobile_skipped_message" product="device" msgid="1110629752293998468">"Nëse kapërcen lidhjen Wi‑Fi:\n\n"<li>"Pajisja nuk do të ketë lidhje me internetin."</li>\n\n<li>"Nuk do të marrësh përditësime të softuerëve derisa të lidhesh me internetin."</li>\n\n<li>"Nuk mund të aktivizosh funksionet e mbrojtjes së pajisjes në këtë moment."</li></string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="8271524692702309267">"Nëse kapërcen lidhjen Wi‑Fi:\n\n"<li>"Telefoni nuk do të ketë lidhje me internetin."</li>\n\n<li>"Nuk do të marrësh përditësime të softuerëve derisa të lidhesh me internetin."</li>\n\n<li>"Nuk mund të aktivizosh funksionet e mbrojtjes së pajisjes në këtë moment."</li></string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Tableti nuk mund të lidhej me këtë rrjet Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="device" msgid="8870885845666880869">"Pajisja nuk mund të lidhej me këtë rrjet Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefoni nuk mundi të lidhej me këtë rrjet Wi-Fi."</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Rrjetet e ruajtura"</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Cilësimet e Wi‑Fi"</string>
    <string name="wifi_configure_titlebar" msgid="7977475161589303074">"Konfiguro Wi‑Fi"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresa MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresa e IP-së"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Rrjetet e ruajtura"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Cilësimet e IP-së"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"Cilësimet e Wi-Fi nuk disponohen për këtë përdorues"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Ruaj"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Anulo"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Shkruaj një adresë të vlefshme IP-je."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Shkruaj një adresë të vlefshme porte kalimi."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Shkruaj një adresë të vlefshme DNS-je."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Shkruaj një gjatësi prefiksi rrjeti mes 0 dhe 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Porta e kalimit"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Gjatësia e prefiksit të rrjetit"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informacioni i pajisjes"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Kujtoje këtë lidhje"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Kërko pajisje"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Po kërkon..."</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Riemërto pajisjen"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Pajisjet homologe"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Grupet r ruajtura në memorie"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Nuk mund të lidhej."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Riemërtimi i pajisjes dështoi."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Të shkëputet?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Nëse shkëputesh, lidhja me <xliff:g id="PEER_NAME">%1$s</xliff:g> do të mbyllet."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Nëse shkëputesh, lidhja jote me <xliff:g id="PEER_NAME">%1$s</xliff:g> dhe <xliff:g id="PEER_COUNT">%2$s</xliff:g> pajisje të tjera do të përfundojë."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Të anulohet ftesa?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Dëshiron të anulosh ftesën për t\'u lidhur me <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Të harrohet ky grup?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Zona e lirë qasjeje Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Zonë e lirë qasjeje për Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="3800646230853724318">"Përdor lidhjen celulare për të ofruar rrjetin Wi‑Fi"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Po aktivizon zonën e qasjes..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Po çaktivizon zonën e qasjes..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Zona e qasjes e lëvizshme <xliff:g id="NETWORK_SSID">%1$s</xliff:g> është aktive"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Gabim në zonën e lirë të qasjes Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Konfiguro zonën e qasjes Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Konfigurimi i zonës së qasjes Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5618031116920832182">"Zona e lirë e qasjes Wi-FI e AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"Zonë e lirë qasjeje Wi-Fi <xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g>"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"Zona Android e qasjes së lirë për internet"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Telefonata me Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="9008010480466359578">"Aktivizo \"Telefonatën me Wi-Fi\""</string>
    <string name="wifi_calling_suggestion_summary" msgid="3765923249566552233">"Përdor Wi-Fi në vend të rrjetit celular"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Preferenca e telefonatës"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="8149690312199253909">"Modaliteti i telefonatës me Wi-Fi"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="2124257075906188844">"Preferohet Wi-Fi"</item>
    <item msgid="5267397515594230396">"Preferohen të dhënat celulare"</item>
    <item msgid="3132912693346866895">"Vetëm Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values">
    <item msgid="4799585830102342375">"2"</item>
    <item msgid="1171822231056612021">"1"</item>
    <item msgid="3194458950573886239">"0"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_without_wifi_only">
    <item msgid="5782108782860004851">"Preferohet Wi-Fi"</item>
    <item msgid="9006785365352731433">"Preferohen të dhënat celulare"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values_without_wifi_only">
    <item msgid="2339246858001475047">"2"</item>
    <item msgid="6200207341126893791">"1"</item>
  </string-array>
    <string name="wifi_calling_off_explanation" msgid="2597566001655908391">"Kur telefonata me Wi-Fi është e aktivizuar, telefoni mund t\'i kalojë telefonatat nëpërmjet rrjeteve Wi-Fi ose nëpërmjet rrjetit të operatorit celular, në varësi të preferencës dhe se cili sinjal është më i fortë. Para se të aktivizosh këtë funksion, kontakto me operatorin celular në lidhje me tarifat dhe detaje të tjera."</string>
    <string name="emergency_address_title" msgid="3571902448699714454">"Përditëso adresën e urgjencës"</string>
    <string name="emergency_address_summary" msgid="306028701568728126">"Adresa përdoret nga shërbimet e urgjencës si vendndodhja jote nëse telefonon në 911 me WiFi"</string>
    <string name="home_settings" msgid="212375129455718176">"Ekrani kryesor"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Paraqitja"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Tingulli"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Volumet"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Efektet e muzikës"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Volumi i ziles"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Dridhje kur është \"në heshtje\""</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Zëri i parazgjedhur i njoftimit"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Toni i ziles"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Njoftimi"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Përdor volumin e telefonatës hyrëse për njoftime"</string>
    <string name="home_work_profile_not_supported" msgid="7457951997970419085">"Profilet e punës nuk mbështeten"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Tingulli i parazgjedhur i njoftimit"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Media"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Cakto volumin për muzikë dhe video"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarmi"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Cilësimet e audios për stacionin e bashkëngjitur"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tonet e bllokut të tasteve"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Tingujt e trokitjes"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Tingulli i kyçjes së ekranit"</string>
    <string name="haptic_feedback_enable_title" msgid="7152163068278526530">"Dridhje pas trokitjes"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Anulimi i zhurmës"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muzikë, video, lojëra dhe media të tjera"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Toni i ziles dhe njoftimet"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Njoftimet"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmet"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Hiq tingullin e ziles dhe njoftimeve"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Çaktivizo zërin për muzikën dhe \"mediat\" e tjera"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Vendosi në heshtje njoftimet"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Çaktivizo zërin e alarmeve"</string>
    <string name="dock_settings" msgid="1820107306693002541">"lidh me stacionin"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Cilësimet e stacionit"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Cilësimet për stacionin e lidhur të desktopit"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Cilësimet për stacionin e lidhur të makinës"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tableti nuk u stacionua"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefoni nuk u stacionua"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Cilësimet për stacionin e lidhur"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Stacioni nuk u gjet"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Duhet të futësh tabletin në stacion para se të konfigurosh audion e stacionit."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Duhet të vendosësh telefonin te stacioni para se të konfigurosh audion e stacionit."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Tingulli i vendosjes në stacion"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Lësho një tingull kur futet ose hiqet tableti nga stacioni"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Lësho një tingull kur futet ose hiqet telefoni nga stacioni"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Mos lësho asnjë tingull kur futet ose hiqet tableti nga stacioni"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Mos lësho asnjë tingull kur futet ose hiqet telefoni nga stacioni"</string>
    <string name="account_settings" msgid="6403589284618783461">"Llogaritë"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Llogaritë e profilit të punës - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Llogaritë e profilit personal"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Llogari pune - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Llogari personale - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Kërko"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Menaxho cilësimet dhe historikun e kërkimit"</string>
    <string name="display_settings" msgid="7965901687241669598">"Ekrani"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Ekran me rrotullim automatik"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Ndërro orientimin automatikisht kur rrotullon tabletin"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Ndrysho automatikisht orientimin kur rrotullon telefonin"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Ndërro orientimin automatikisht kur rrotullon tabletin"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Ndrysho orientimin automatik kur rrotullon telefonin"</string>
    <string name="brightness" msgid="8480105032417444275">"Niveli i ndriçimit"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Ndriçimi"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Rregullo ndriçimin e ekranit"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Ndriçimi i përshtatshëm"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Optimizo nivelin e ndriçimit sipas ambientit"</string>
    <string name="night_display_title" msgid="2626451512200357686">"Drita e natës"</string>
    <string name="night_display_text" msgid="4535302797673277668">"Drita e natës e ngjyros ekranin në të kuqe. Kjo e bën më të lehtë shikimin e ekranit në dritë të zbehtë dhe mund të të ndihmojë të flesh gjumë më lehtë."</string>
    <string name="night_display_category_schedule" msgid="2044072617637348966">"Orari"</string>
    <string name="night_display_category_status" msgid="1952928783124400330">"Statusi"</string>
    <string name="night_display_auto_mode_title" msgid="8046314360381608455">"Aktivizo automatikisht"</string>
    <string name="night_display_auto_mode_never" msgid="6723636142053240947">"Asnjëherë"</string>
    <string name="night_display_auto_mode_custom" msgid="6012300346981608242">"Personalizo programin"</string>
    <string name="night_display_auto_mode_twilight" msgid="2123345097508167094">"Nga perëndimi në agim"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Koha e nisjes"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Koha e përfundimit"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Fikur / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="8865054549719499274">"Asnjëherë mos e aktivizo automatikisht"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="4962295097132112885">"Aktivizoje automatikisht në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="5520577516590422267">"Aktivizoje automatikisht kur perëndon dielli"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Ndezur / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="44005841579902825">"Mos e çaktivizo asnjëherë automatikisht"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="4350556852471560173">"Çaktivizoje automatikisht në <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="6122152828111119250">"Çaktivizoje automatikisht në agim"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Në gjendje gjumi"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Ekrani çaktivizohet"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Kur, <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> pa aktivitet"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Imazhi i sfondit"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Ndrysho imazhin e sfondit"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Personalizo ekranin"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Zgjidh imazhin e sfondit nga"</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Mbrojtësi i ekranit"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Kur është i vënë në stacion ose në fjetje dhe ngarkim"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Në të dyja rastet"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Gjatë ngarkimit"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Kur vendoset në stacion"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Çaktivizuar"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"Për të kontrolluar se çfarë ndodh kur telefonin e vendos te stacioni dhe/ose në gjumë, aktivizo mbrojtësin e ekranit."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8644479926302707286">"Kur të fillojë mbrojtësi i ekranit"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Fillo tani"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Cilësimet"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Ndriçimi automatik"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Ngrije për ta zgjuar"</string>
    <string name="doze_title" msgid="2259176504273878294">"Shfaqja e ambientit"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Zgjoje ekranin kur të merren njoftime"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Madhësa e shkrimit"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Bëje tekstin më të madh ose më të vogël"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Kyçja e kartës SIM"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Konfiguro kyçjen e kartës SIM"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Kyçja e kartës SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Kyçe kartën SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Kërko kodin PIN për të përdorur tabletin"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Kërko kod PIN për të përdorur telefonin"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Kërko kodin PIN për të përdorur tabletin"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Kërko kod PIN për të përdorur telefonin"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Ndrysho PIN-in e kartës SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"PIN-i i kartës SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Kyçe kartën SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Shkyçe kartën SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Kodi i vjetër PIN i kartës SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"PIN-i i ri i kartës SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Shkruaj përsëri kodin e ri PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Kodi PIN i kartës SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Kodi PIN është i pasaktë"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"Kodet PIN nuk përputhen"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"Kodi PIN nuk ndryshoi.\nKod PIN i gabuar."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"PIN-i i kartës SIM u ndryshua me sukses."</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Karta SIM ende e kyçur.\nKod PIN i gabuar."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"Në rregull"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Anulo"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"U gjetën shumë karta SIM"</string>
    <string name="sim_multi_sims_summary" msgid="7018740080801483990">"Zgjidh kartën SIM që preferon për të dhënat celulare."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Të ndryshohet kartën SIM për të dhënat?"</string>
    <string name="sim_change_data_message" msgid="1313940695939674633">"Të përdoret karta <xliff:g id="NEW_SIM">%1$s</xliff:g> në vend të <xliff:g id="OLD_SIM">%2$s</xliff:g> për të dhënat celulare?"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Të përditësohet karta e preferuar SIM?"</string>
    <string name="sim_preferred_message" msgid="301251431163650167">"<xliff:g id="NEW_SIM">%1$s</xliff:g> është karta e vetme SIM në pajisjen tënde. Dëshiron që ta përdorësh këtë kartë SIM për të dhënat celulare, telefonatat dhe mesazhet SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"PIN-i i kartës SIM është i pasaktë. Tani duhet të kontaktosh operatorin për ta shkyçur pajisjen tënde."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="other">Kodi PIN i kartës SIM është i pasaktë. Të kanë mbetur edhe <xliff:g id="NUMBER_1">%d</xliff:g> tentativa.</item>
      <item quantity="one">Kodi PIN i kartës SIM është i pasaktë. Të ka mbetur edhe <xliff:g id="NUMBER_0">%d</xliff:g> tentativë para se të duhet të kontaktosh me operatorin tënd celular për të shkyçur pajisjen.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Operac. kodit PIN të kartës SIM dështoi!"</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Statusi i tabletit"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Statusi i telefonit"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Përditësimet e sistemit"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Versioni i Android-it"</string>
    <string name="security_patch" msgid="8438384045870296634">"Niveli i korrigjimit të sigurisë së Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Numri i modelit"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID-ja e pajsjes"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Versioni i brezit të bazës"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Versioni i bërthamës"</string>
    <string name="build_number" msgid="3075795840572241758">"Numri i ndërtimit"</string>
    <string name="selinux_status" msgid="6212165375172061672">"Statusi i SELinux"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Nuk ofrohet"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Statusi"</string>
    <string name="device_status" msgid="607405385799807324">"Statusi"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Statusi i baterisë, rrjeti dhe informacione të tjera"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Numri i telefonit, sinjali etj."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Hapësira ruajtëse"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Hapësira ruajtëse"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Cilësimet e hapësirës ruajtëse"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Shkëput hapësirën ruajtëse të USB-së dhe shiko hapësirën ruajtëse të lirë"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Shkëput kartën SD. Shiko hapësirën e lirë për ruajtje."</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Numri im i telefonit"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MINUTA"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Versioni PRL"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="952552009117455166">"Lloji i rrjetit celular"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informacioni i operatorit"</string>
    <string name="status_data_state" msgid="4578972321533789767">"Gjendja e rrjetit celular"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Gjendja e shërbimit"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Fuqia e sinjalit"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Rrjeti"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresa MAC e Wi‑Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresa e Bluetooth-it"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Numri i serisë"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Nuk ofrohet"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Koha aktive"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Koha e zgjimit"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Hapësira e brendshme për ruajtje"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Hapësira për ruajtje e USB-së"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Karta SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"E lirë"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"E gatshme (vetëm për lexim)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Hapësira totale"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Po llogarit…"</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Apl. dhe të dhënat e tyre"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Media"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Shkarkimet"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Fotografitë, videot"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Audio (muzikë, zile etj.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Skedarë të tjerë"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Të dhënat e memories specifike"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Shkëput hapësirën ruajtëse të ndarë"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Shkëput kartën SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Çmonto hapësirën ruajtëse të brendshme të USB-së"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Çmontoje kartën SD që ta heqësh në mënyrë të sigurt"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Fut USB-në për lidhje"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Vendos një kartë SD për lidhje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Lidh hapësirën për ruajtje të USB-së"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Lidh kartën SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Spastro hapësirën USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Spastro kartën SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Spastron të gjitha të dhënat në hapësirën ruajtëse të brendshme të USB-së, sikurse muzikën dhe fotografitë"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Spastro të gjitha të dhënat në kartën SD, si muzikën dhe fotografitë"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Të pastrohen të dhënat e memories specifike?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Kjo do të pastrojë të dhënat e memories specifike për të gjitha aplikacionet."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funksioni MTP ose PTP është aktiv"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Të shkëputet USB-ja?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Të çmontohet karta SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Nëse e çmonton hapësirën ruajtëse të USB-së, disa aplikacione që po përdor do të ndalojnë dhe mund të mos mundësohen deri sa ta montosh përsëri hapësirën ruajtëse të USB-së."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Nëse shkëput kartën SD, disa aplikacione që po përdor do të ndalojnë dhe mund të bëhen të papërdorshme derisa të lidhësh sërish kartën SD."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"Nuk mundi të shkëpuste hapësirën për ruajtje të USB-së. Provo sërish më vonë."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Karta SD nuk mund të shkëputej. Provo përsëri më vonë."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Hapësira ruajtëse e USB-së do të shkëputet."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Karta SD do të shkëputet."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Po çmontohet"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Çmontimi në vazhdim"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Hapësira e ruajtjes po mbaron"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Disa funksione të sistemit, si sinkronizimi, mund të mos punojnë si duhet. Provo të lirosh hapësirën duke fshirë ose duke hequr artikujt, si për shembull aplikacione ose përmbajtje \"media\"."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Riemërto"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Monto"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Nxirr"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formato"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formato si të lëvizshme"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formato si të brendshme"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Migro të dhënat"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Harroje"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Konfiguro"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Eksploro"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Liro hapësirën"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Menaxho hapësirën e ruajtjes"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Lidhja e kompjuterit me USB-në"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Lidh si"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Pajisje e jashtme \"media\" (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Lejon që të transferosh skedarët \"media\" në Windows ose duke përdorur \"Transferimin e skedarëve të Androidit\" në Mac (shiko www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Kamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Lejon që të transferosh fotografi duke përdorur softuerin e kamerës dhe të transferosh çdo skedar në kompjuterë që nuk e mbështesin MTP-në"</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Lejo që aplikacionet e aktivizuara të MIDI-së të funksionojnë në USB me softuerin MIDI në kompjuterin tënd."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Përdorues të tjerë"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Hapësira për ruajtje e pajisjes"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Hapësira ruajtëse e lëvizshme"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"<xliff:g id="USED">%1$s</xliff:g> të përdorura nga <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="1303803057698959872">"Përdorur nga gjithsej <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Përdorur nga gjithsej <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"<xliff:g id="NAME">%1$s</xliff:g> u montua"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Nuk mundi të lidhte <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"<xliff:g id="NAME">%1$s</xliff:g> u nxorr në mënyrë të sigurt"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të nxirrej në mënyrë të sigurt"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"<xliff:g id="NAME">%1$s</xliff:g> është i formatuar"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të formatohej"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Riemërto hapësirën ruajtëse"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"Kjo <xliff:g id="NAME_0">^1</xliff:g> është nxjerrë në mënyrë të sigurt, por është akoma e disponueshme. \n\nPër të përdorur këtë <xliff:g id="NAME_1">^1</xliff:g>, duhet ta montosh në fillim."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Kjo <xliff:g id="NAME_0">^1</xliff:g> është e dëmtuar. \n\nPër të përdorur këtë <xliff:g id="NAME_1">^1</xliff:g>, duhet ta konfigurosh në fillim."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Kjo pajisje nuk e mbështet këtë <xliff:g id="NAME_0">^1</xliff:g>. \n\nPër të përdorur këtë <xliff:g id="NAME_1">^1</xliff:g> me këtë pajisje, duhet ta konfigurosh në fillim."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Pas formatimit, kartën <xliff:g id="NAME_0">^1</xliff:g> mund ta përdorësh në pajisje të tjera. \n\nTë gjitha të dhënat në <xliff:g id="NAME_1">^1</xliff:g> do të fshihen. Rekomandohet që të kryesh rezervimin në fillim. \n\n"<b>"Rezervo fotografitë dhe artikujt e tjerë \"media\""</b>" \nZhvendosi skedarët \"media\" në hapësira alternative ruajtjeje në këtë pajisje ose transferoji ato në një kompjuter duke përdorur një kabllo USB-je. \n\n"<b>"Rezervo aplikacionet"</b>" \nTë gjitha aplikacionet e ruajtura në <xliff:g id="NAME_6">^1</xliff:g> do të çinstalohen dhe të dhënat e tyre do të fshihen. Për t\'i ruajtur këto aplikacione, zhvendosi në hapësira alternative ruajtjeje në këtë pajisje."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Kur ta nxjerrësh këtë <xliff:g id="NAME_0">^1</xliff:g>, aplikacionet e ruajtura në të do të ndalojnë së funksionuari ndërsa skedarët \"media\" nuk do të jenë të përdorshëm derisa ta fusësh atë sërish."</b>" \n\n<xliff:g id="NAME_1">^1</xliff:g> është formatuar për të funksionuar vetëm me këtë pajisje dhe nuk do të funksionojë me pajisje të tjera."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Për të përdorur aplikacionet, fotografitë ose të dhënat që përmban <xliff:g id="NAME">^1</xliff:g>, rifute atë. \n\nSi alternativë, mund të zgjedhësh ta harrosh këtë magazinë nëse pajisja nuk mund të përdoret. \n\nNëse zgjedh që ta harrosh, të gjitha të dhënat që përmban pajisja do të humbasin përgjithmonë. \n\nAplikacionet mund t\'i instalosh sërish më vonë, por të dhënat e ruajtura në këtë pajisje do të humbasin."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Harroje <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Të gjitha aplikacionet, fotografitë dhe të dhënat e ruajtura në këtë <xliff:g id="NAME">^1</xliff:g> do të humbasin përgjithmonë."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Aplikacionet"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Imazhet"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Videot"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Audio"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Të dhënat e memories specifike"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Tjetër"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Sistemi"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Eksploro <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="5343550781234524040">"Përfshin po ashtu skedarët e ndarë që janë ruajtur nga aplikacionet, skedarët e shkarkuar nga interneti ose me Bluetooth, skedarët e Android e të tjera. \n\nPër të parë të gjitha përmbajtjet në këtë <xliff:g id="NAME">^1</xliff:g>, trokit tek \"Eksploro\"."</string>
    <string name="storage_detail_dialog_system" msgid="3058775028564971102">"Sistemi përfshin skedarë që përdoren në nivel të brendshëm nga sistemi operativ Android. \n\nKëta skedarë nuk mund të shikohen individualisht."</string>
    <string name="storage_detail_dialog_user" msgid="1675756743326079688">"<xliff:g id="USER_0">^1</xliff:g> mund të ketë ruajtur fotografi, muzikë, filma, aplikacione ose të dhëna të tjera që po zënë <xliff:g id="SIZE">^2</xliff:g> nga hapësira ruajtëse. \n\npër të parë detajet, kalo te <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Konfiguro <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Përdore si hapësirë portative ruajtjeje"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Për të zhvendosur fotografi dhe artikuj të tjerë \"media\" mes pajisjeve."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Përdore si hapësirë të brendshme ruajtjeje"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"Për të ruajtur diçka vetëm në këtë pajisje, duke përfshirë aplikacionet dhe fotografitë. Kërkon formatim që e parandalon atë të funksionojë me pajisje të tjera."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Formato si hapësirë të brendshme ruajtjeje"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Kjo kërkon që <xliff:g id="NAME_0">^1</xliff:g> të formatohet për ta bërë të sigurt atë. \n\nPas formatimit, <xliff:g id="NAME_1">^1</xliff:g> do të funksionojë vetëm në këtë pajisje. \n\n"<b>"Formatimi fshin të gjitha të dhënat që ruhen aktualisht në <xliff:g id="NAME_2">^1</xliff:g>."</b>" Për të shmangur humbjen e të dhënave, rekomandohet rezervimi i tyre."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formatoje si hapësirë ruajtëse të lëvizshme"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Kjo kërkon që <xliff:g id="NAME_0">^1</xliff:g> të formatohet. \n\n"<b>"Formatimi fshin të gjitha të dhënat e ruajtura aktualisht te <xliff:g id="NAME_1">^1</xliff:g>."</b>" Për të shmangur humbjen e të dhënave, rekomandohet rezervimi i tyre."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Fshi dhe formato"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"<xliff:g id="NAME">^1</xliff:g> po formatohet..."</string>
    <string name="storage_wizard_format_progress_body" msgid="4445041233802828430">"<xliff:g id="NAME">^1</xliff:g> nuk duhet të hiqet gjatë formatimit."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Zhvendos të dhënat në hapësirën e re të ruajtjes"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Mund të zhvendosësh fotografitë, skedarët dhe disa aplikacione te kjo <xliff:g id="NAME">^1</xliff:g> e re. \n\nZhvendosja kërkon rreth <xliff:g id="TIME">^2</xliff:g> dhe do të lirojë <xliff:g id="SIZE">^3</xliff:g> në hapësirën e brendshme. Disa aplikacione nuk do të funksionojnë gjatë këtij procesi."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Zhvendos tani"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Zhvendos më vonë"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Zhvendos të dhënat"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Zhvendosja kërkon rreth <xliff:g id="TIME">^1</xliff:g> dhe do të lirojë <xliff:g id="SIZE">^2</xliff:g> nga <xliff:g id="NAME">^3</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Zhvendos"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Po zhvendos të dhënat..."</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Gjatë zhvendosjes: \n• <xliff:g id="NAME">^1</xliff:g> nuk duhet të hiqet. \n• Disa apl. nuk do të funksionojnë si duhet. \n• Mbaje pajisjen të ngarkuar."</string>
    <string name="storage_wizard_ready_title" msgid="5381632402953258267">"<xliff:g id="NAME">^1</xliff:g> është gati"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"<xliff:g id="NAME">^1</xliff:g> është gati për t\'u përdorur me fotografitë dhe skedarët e tjerë."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"<xliff:g id="NAME">^1</xliff:g> po funksionon. \n\nPër të zhvendosur fotografitë, skedarët dhe të dhënat e aplikacioneve te kjo pajisje, shko te Cilësimet &gt; Hapësira ruajtëse."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Zhvendos <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Zhvendosja e aplikacionit <xliff:g id="APP">^1</xliff:g> dhe të dhënave të tij te <xliff:g id="NAME_0">^2</xliff:g> do të zgjasë vetëm pak çaste. Nuk do të jesh në gjendje ta përdorësh aplikacionin derisa zhvendosja të përfundojë. \n\n<xliff:g id="NAME_1">^2</xliff:g> nuk duhet të hiqet gjatë zhvendosjes."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Po zhvendos <xliff:g id="APP">^1</xliff:g> ..."</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Mos e hiq kartën <xliff:g id="NAME">^1</xliff:g> gjatë zhvendosjes. \n\nAplikacioni <xliff:g id="APP">^2</xliff:g> në këtë pajisje nuk do të mund të përdoret derisa të përfundojë zhvendosja."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Anulo zhvendosjen"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Kjo <xliff:g id="NAME_0">^1</xliff:g> duket se është e ngadaltë. \n\nMund të vazhdosh, por aplikacionet e zhvendosura në këtë vend mund të pengohen dhe transferimi i të dhënave mund të kërkojë shumë kohë. \n\nKi parasysh të përdorësh një <xliff:g id="NAME_1">^1</xliff:g> më të shpejtë për një cilësi më të mirë të funksionimit."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Statusi i baterisë"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Niveli i baterisë"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN-të"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Redakto pikën e qasjes"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nuk është caktuar"</string>
    <string name="apn_name" msgid="4115580098369824123">"Emri"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN-ja"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Përfaqësuesi"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Porta"</string>
    <string name="apn_user" msgid="455637547356117761">"Emri i përdoruesit"</string>
    <string name="apn_password" msgid="5412301994998250968">"Fjalëkalimi"</string>
    <string name="apn_server" msgid="2436185314756372858">"Serveri"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC-ja"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Përfaqësuesi i MMS-ve"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Porta e MMS-ve"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC-ja"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC-ja"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Lloji i vërtetimit"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Asnjë"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ose CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Lloji i APN-së"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokolli i APN-së"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokolli i APN-së në roaming"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Aktivizo/çaktivizo APN-në"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"Rrjeti APN u aktivizua"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"Rrjeti APN u çaktivizua"</string>
    <string name="bearer" msgid="594270280031923558">"Bartësi"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Lloji i MVNO-së"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Vlera e MVNO-së"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Fshi APN-në"</string>
    <string name="menu_new" msgid="3014205883303921729">"APN e re"</string>
    <string name="menu_save" msgid="8109345640668285399">"Ruaj"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Injoro"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Fusha Emri nuk mund të jetë bosh."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"Rrjeti APN nuk mund të jetë bosh."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Fusha e MCC-së duhet të ketë 3 shifra."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Fusha e MNC-së duhet të ketë 2 ose 3 shifra."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Po restauron cilësimet e APN-së me parazgjedhje."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Rivendos të parazgjedhurën"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Rivendosja e cilësimeve të APN-së me parazgjedhje përfundoi."</string>
    <string name="reset_network_title" msgid="4557113742173895074">"Rivendosja e rrjetit"</string>
    <string name="reset_network_desc" msgid="581668983587311282">"Kjo do të rivendosë të gjitha cilësimet e rrjetit, përfshirë:\n\n"<li>"Wi‑Fi"</li>\n<li>"Të dhënat celulare"</li>\n<li>"Bluetooth-in"</li></string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Rivendos cilësimet"</string>
    <string name="reset_network_final_desc" msgid="6388371121099245116">"Të rivendosen të gjitha cilësimet e rrjetit? Ky veprim nuk mund të zhbëhet!"</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Rivendos cilësimet"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Të rivendosen?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Rivendosja e rrjetit nuk është e disponueshme për këtë përdorues"</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Cilësimet e rrjetit janë rivendosur"</string>
    <string name="device_reset_title" msgid="2384019005638768076">"Rivendos pajisjen"</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Konfig. i fabrikës"</string>
    <string name="master_clear_desc" product="tablet" msgid="9146059417023157222">"Kjo do t\'i fshijë të gjitha të dhënat nga "<b>"hapësira e brendshme për ruajtje"</b>" e tabletit, përfshirë:\n\n"<li>"Llogarinë e Google"</li>\n<li>"Të dhënat e sistemit dhe aplikacioneve si dhe cilësimet"</li>\n<li>"Aplikacionet e shkarkuara"</li></string>
    <string name="master_clear_desc" product="default" msgid="4800386183314202571">"Kjo do t\'i fshijë të gjitha të dhënat nga "<b>"hapësira e brendshme për ruajtje"</b>" e telefonit, përfshirë:\n\n"<li>"Llogarinë e Google"</li>\n<li>"Të dhënat e sistemit dhe aplikacioneve si dhe cilësimet"</li>\n<li>"Aplikacionet e shkarkuara"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Je i identifikuar aktualisht në llogaritë e mëposhtme:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"Ka përdorues të tjerë të pranishëm në këtë pajisje.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Muzika"</li>\n<li>"Fotografitë"</li>\n<li>"Të dhëna të tjera të përdoruesit"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Për të hequr muzikën, fotografitë dhe të dhëna të tjera të përdoruesit, "<b>"hapësira ruajtëse e USB-së"</b>" duhet të spastrohet."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Për të hequr muzikën, fotografitë dhe të dhëna të tjera të përdoruesit, "<b>"karta SD"</b>" duhet të spastrohet."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Fshi hapësirën ruajtëse të USB-së"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Spastroje kartën SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Spastro të gjitha të dhënat në hapësirën ruajtëse të brendshme të USB-së, si muzikën ose fotografitë"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Spastro të gjitha të dhënat në kartën SD, si muzikën ose fotografitë"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Rivendos tabletin"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Rivendose telefonin"</string>
    <string name="master_clear_final_desc" msgid="7318683914280403086">"Të spastrohen të gjitha informacionet e tua personale dhe aplikacionet e shkarkuara? Ky veprim nuk mund të kthehet mbrapsht!"</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Spastroji të gjitha"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Nuk u krye një rivendosje sepse shërbimi Pastrimi i sistemit nuk është i disponueshëm."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Të rivendoset?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Rivendosja në gjendjen e fabrikës nuk ofrohet për këtë përdorues"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Po spastron"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Qëndro në pritje..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Cilësimet e telefonatave"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Konfiguro postën zanore, transferimin e telefonatave, telefonatat në pritje dhe ID-në e telefonuesit"</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="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Nuk mund të ndajë internetin ose të përdorë zonat e qasjes në internet kur \"Kursyesi i të dhënave\" është aktiv"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Ndarje përmes USB-së"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"Me t\'u lidhur USB-ja, kontrollo për të ndarë lidhjen"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"E ndarë"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="8427089411146908205">"Nuk mund të ndahet kur është në përdorim hapësira ruajtëse e USB-së"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"USB-ja nuk është e lidhur"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Lidhe për ta aktivizuar"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Gabim në ndarjen përmes USB-së"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Ndarje interneti përmes Bluetooth-it"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="4328374808439440517">"Po ndan lidhjen e internetit të këtij tableti"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="7451579908917710359">"Po ndan lidhjen e internetit të këtij telefoni"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="7296104766087335891">"Po ndan lidhjen me internet të këtij tableti me 1 pajisje"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="2785474869740805972">"Po ndan lidhjen e internetit të këtij telefoni me 1 pajisje"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="7345108029216525495">"Lidhja e internetit të këtij tableti po ndahet me <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> pajisje"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="2992288063706153665">"Lidhja e internetit të këtij telefoni po ndahet me <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> pajisje"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6630416508030836214">"Po ndan lidhjen e internetit të kësaj pajisjeje <xliff:g id="DEVICE_NAME">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="3737828501935728137">"Lidhja e internetit të këtij tableti nuk po ndahet"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="9099562374002272901">"Nuk po e ndan lidhjen e internetit të këtij telefoni"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Nuk është i ndarë"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Ndarja e internetit nuk mund të bëhet për më shumë se <xliff:g id="MAXCONNECTION">%1$d</xliff:g> pajisje."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Ndarja e internetit do të çaktivizohet për <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Ndihma"</string>
    <string name="network_settings_title" msgid="4871233236744292831">"Rrjetet celulare"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Plani celular"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"Aplikacioni për SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Të ndryshohet aplikacioni i SMS-ve?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Të përdoret <xliff:g id="NEW_APP">%1$s</xliff:g> në vend të <xliff:g id="CURRENT_APP">%2$s</xliff:g> si aplikacioni për SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Të përdoret <xliff:g id="NEW_APP">%s</xliff:g> si aplikacioni për SMS-të?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Të ndryshohet ndihmësi i Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Të përdoret <xliff:g id="NEW_APP">%1$s</xliff:g> në vend të <xliff:g id="CURRENT_APP">%2$s</xliff:g> për të menaxhuar lidhjet e rrjetit?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Të përdoret <xliff:g id="NEW_APP">%s</xliff:g> për të menaxhuar lidhjet e rrjetit?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Operatori i kartës SIM është i panjohur"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"%1$s nuk ka faqe të sigurt e të njohur"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Vendos kartën SIM dhe rinise"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Lidhu me internetin"</string>
    <string name="location_title" msgid="1029961368397484576">"Vendndodhja ime"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Vend. për profilin e punës"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Modaliteti"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Saktësi e lartë"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Kursimi i baterisë"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Vetëm pajisja"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Vendndodhja është çaktivizuar"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Kërkesat e vendndodhjeve të fundit"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Asnjë aplikacion nuk ka kërkuar vendndodhje kohët e fundit"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Shërbimet e vendndodhjes"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Përdorimi i lartë i baterisë"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Përdorim i ulët baterie"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Vendndodhja"</string>
    <string name="location_mode_high_accuracy_description" msgid="5703350404315028607">"Përdor funksionin GPS, Wi‑Fi, Bluetooth dhe rrjetet celulare për të përcaktuar vendndodhjen"</string>
    <string name="location_mode_battery_saving_description" msgid="8361848607963121770">"Përdor funksionin Wi‑Fi, Bluetooth dhe rrjetet celulare për të përcaktuar vendndodhjen"</string>
    <string name="location_mode_sensors_only_description" msgid="788127681455735699">"Përdor GPS-në për të përcaktuar vendndodhjen"</string>
    <string name="location_menu_scanning" msgid="8536245838478802959">"Skanimi"</string>
    <string name="location_scanning_screen_title" msgid="4408076862929611554">"Po skanon"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Skanimi i Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="8036382029606868081">"Përmirëso vendndodhjen duke lejuar aplikacionet dhe shërbimet e sistemit të zbulojnë rrjetet Wi-Fi në çdo kohë."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Skanimi i Bluetooth-it"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="8602726521250591852">"Përmirëso vendndodhjen duke lejuar aplikacionet dhe shërbimet e sistemit të zbulojnë pajisjet me Bluetooth në çdo kohë."</string>
    <string name="location_network_based" msgid="6010456018401296590">"Vend. rrjetit Wi‑Fi e celular"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Lejo aplikacionet të përdorin shërbimin e vendndodhjes së Google për të llogaritur më shpejt vendndodhjen tënde. Të dhënat e vendndodhjes do të jenë anonime dhe do të mblidhen e do t\'i dërgohen Google."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Vendndodhja u përcaktua nga Wi‑Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satelitët GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Lejo aplikacionet të përdorin GPS-në në tablet për të shënuar vendndodhjen tënde"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Lejo aplikacionet të përdorin GPS-në në telefon për të përcaktuar me saktësi vendndodhjen tënde"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Përdor GPS-në e ndihmuar"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Përdor serverin për të ndihmuar GPS-në (anulo zgjedhjen për të zvogëluar përdorimin e rrjetit)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Përdor serverin për të ndihmuar GPS-në (anulo zgjedhjen për të përmirësuar veprimtarinë e GPS-së)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Vendndodhja dhe kërkimi në Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Lejo Google të përdorë vendndodhjen për të përmirësuar rezultatet e kërkimit dhe shërbime të tjera"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Qasja në vendndodhjen time"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Lejoji aplikacionet që kanë kërkuar lejen tënde të përdorin informacionin e vendndodhjes"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Burimet e vendndodhjes"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Rreth tabletit"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Informacion mbi telefonin"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"Rreth emulatorit"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Shiko informacionin ligjor, statusin dhe versionin e softuerit"</string>
    <string name="legal_information" msgid="5769301644270604095">"Informacioni ligjor"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Kontribuuesit"</string>
    <string name="manual" msgid="3025943393642974445">"Manuale"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Etiketat rregullatore"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Manuali rregullator dhe i sigurisë"</string>
    <string name="copyright_title" msgid="865906688917260647">"Të drejtat e autorit"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenca"</string>
    <string name="terms_title" msgid="7697580845616764642">"Kushtet e përgjithshme"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Licenca e WebView në sistem"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Imazhet e sfondit"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Ofruesit e imazheve satelitore:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Manuale"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Ka një problem me ngarkimin e manualit."</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Licencat me burim të hapur"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Ka një problem me ngarkimin e licencave."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Po ngarkon..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informacioni i sigurisë"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informacioni i sigurisë"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="250674109915859456">"Nuk ke një lidhje të dhënash. Për të parë këtë informacion tani, shko te %s nga një kompjuter i lidhur me internetin."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Po ngarkon..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Zgjidh fjalëkalimin"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Zgjidh motivin"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Zgjidh kodin PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Konfirmo fjalëkalimin"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Konfirmo motivin"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Konfirmo kodin tënd PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Fjalëkalimet nuk përputhen"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"Kodet PIN nuk përputhen"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Përzgjedhja e shkyçjes"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Fjalëkalimi është caktuar"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Kodi PIN është caktuar"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Motivi është caktuar"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Përdor motivin e pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Fut kodin PIN të pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Fut fjalëkalimin e pajisjes për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Përdor motivin tënd të punës për të vazhduar"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Fut kodin tënd PIN të punës për të vazhduar"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Fut fjalëkalimin tënd të punës për të vazhduar"</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_pattern" msgid="8548464672947477043">"Përdor motivin e pajisjes për të vazhduar. Kërkohet pas rinisjes së pajisjes."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_pin" msgid="8048122891934295280">"Fut kodin PIN të pajisjes për të vazhduar. Kërkohet pas rinisjes së pajisjes."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_password" msgid="9007679426540259125">"Fut fjalëkalimin e pajisjes për të vazhduar. Kërkohet pas rinisjes së pajisjes."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_pattern" msgid="7462071286473121099">"Përdor motivin tënd të punës për të vazhduar. Kërkohet pas rinisjes së pajisjes."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_pin" msgid="809763184419127790">"Fut kodin tënd PIN të punës për të vazhduar. Kërkohet pas rinisjes së pajisjes."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_password" msgid="8923861444535970646">"Fut fjalëkalimin tënd të punës për të vazhduar. Kërkohet pas rinisjes së pajisjes."</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Kod PIN i gabuar"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Fjalëkalim i gabuar"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Motiv i gabuar"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Siguria e pajisjes"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Ndrysho motivin e shkyçjes"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Ndrysho kodin PIN të shkyçjes"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Vizato një motiv shkyçjeje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Shtyp Menynë për ndihmë."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Hiqe gishtin kur të mbarosh"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Lidh të paktën <xliff:g id="NUMBER">%d</xliff:g> pika. Provo përsëri."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Motivi u regjistrua"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Vizato sërish motivin për ta konfirmuar"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Motivi i ri i shkyçjes"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Konfirmo"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Tërhiq sërish"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Pastro"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Vazhdo"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Motivi i shkyçjes"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Kërko motivin"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Duhet të vizatosh motivin për të shkyçur ekranin"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Bëje motivin të dukshëm"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Bëje të dukshëm motivin e profilit"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Dridhje pas trokitjes"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Butoni i fikjes e kyç menjëherë"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Përveçse kur mbahet i shkyçur nga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Cakto motivin e shkyçjes"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Ndrysho motivin e shkyçjes"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Si të vizatosh një motiv shkyçjeje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Shumë tentativa të pasakta. Provo sërish brenda <xliff:g id="NUMBER">%d</xliff:g> sekondash."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikacioni nuk është i instaluar në telefonin tënd."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Siguria e profilit të punës"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Kyçja e ekranit të profilit të punës"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Përdorni një kyçje të vetme për profilin e punës dhe ekranin e pajisjes"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Të përdoret një kyçje e vetme?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1787427605545808829">"Profili yt i punës dhe ekrani i pajisjes do të përdorin të njëjtën kyçje. Për kyçjen e ekranit të pajisjes tënde do të zbatohet çdo politikë e kyçjes së punës."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="3221303098797469900">"Kyçja e ekranit e punës nuk i plotëson kërkesat e sigurisë së organizatës tënde. Mund të përdorësh të njëjtën kyçje për ekranin e pajisjes tënde dhe për profilin e punës, por do të zbatohet çdo politikë për kyçjen e punës."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="8249970828159656518">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Përdor një kyçje të vetme"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Njësoj si kyçja e ekranit të pajisjes"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Menaxho aplikacionet"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Menaxho dhe hiq aplikacionet e instaluara"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Aplikacionet"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Menaxho aplikacionet, konfiguro shkurtoret e hapjes së shpejtë"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Cilësimet e apl."</string>
    <string name="install_applications" msgid="4872012136210802181">"Burime të panjohura"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Lejo të gjitha burimet e apl."</string>
    <string name="install_unknown_applications_title" msgid="663831043139080992">"Lejon instalimin e aplikacioneve jashtë \"Luaj me Google\""</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Lejo instalimin e aplikacioneve nga burime të panjohura"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Tableti yt dhe të dhënat personale janë më të cenueshme nga sulmet nga burime të panjohura. Ti pranon se je plotësisht përgjegjës për çdo dëm ndaj tabletit ose çdo humbje të dhënash që mund të rezultojë nga përdorimi i këtyre aplikacioneve."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Telefoni dhe të dhënat e tua personale janë më të cenueshme për t\'u sulmuar nga aplikacione të cilat vijnë nga burime të panjohura. Ti pranon se je plotësisht përgjegjës për çdo dëm ndaj telefonit ose çdo humbje të dhënash që mund të rezultojë nga përdorimi i këtyre aplikacioneve."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Cilësimet e përparuara"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Aktivizo më shumë opsione të cilësimeve"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informacioni i apl."</string>
    <string name="storage_label" msgid="8700867073480107253">"Hapësira ruajtëse"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Hap me parazgjedhje"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Parazgjedhjet"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Përputhshmëria e ekranit"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Lejet"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Memoria specifike"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Pastro memorien specifike"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Memoria specifike"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="other">%d artikuj</item>
      <item quantity="one">1 artikull</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Qasje e pastër"</string>
    <string name="controls_label" msgid="7611113077086853799">"Kontrollet"</string>
    <string name="force_stop" msgid="7435006169872876756">"Ndalo me forcë"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Totali"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Aplikacioni"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikacioni i hapësirës ruajtëse të USB-së"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Të dhënat"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Të dhënat e hapësirës ruajtëse të USB-së"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Karta SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Çinstalo"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Çinstaloje për të gjithë përdoruesit"</string>
    <string name="install_text" msgid="884360662922471113">"Instalo"</string>
    <string name="disable_text" msgid="6544054052049395202">"Çaktivizo"</string>
    <string name="enable_text" msgid="9217362512327828987">"Aktivizo"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Pastro të dhënat"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Çinstalo përditësimet"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Ke zgjedhur që ta hapësh këtë aplikacion në mënyrë të parazgjedhur për disa veprime."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Ke zgjedhur ta lejosh këtë aplikacion të krijojë dhe të ketë qasje te të dhënat e tyre."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nuk ka parazgjedhje të caktuara."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Fshi parazgjedhjet"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ky aplikacion mund të mos jetë i projektuar për ekranin tënd. Mund të kontrollosh si përputhet me ekranin tënd këtu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Pyet kur të hapet"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Shkallëzo aplikacionin"</string>
    <string name="unknown" msgid="1592123443519355854">"I panjohur"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Rendit sipas emrit"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Rendit sipas madhësisë"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Shfaq shërbimet që po ekzekutohen"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Shfaq proceset specifike"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplikacioni i emergjencave"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Rivendos preferencat e apl."</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Të rivendosen preferencat e aplikacionit?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Kjo do t\'i rivendosë të gjitha preferencat për:\n\n "<li>"Aplikacionet e çaktivizuara"</li>\n" "<li>"Njoftimet e aplikacioneve të çaktivizuara"</li>\n" "<li>"Aplikacionet e parazgjedhura për veprimet"</li>\n" "<li>"Kufizimet e të dhënave në sfond për aplikacionet"</li>\n" "<li>"Çdo kufizim të lejes"</li>\n\n" Nuk do të humbësh asnjë të dhënë aplikacioni."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Rivendos aplikacionet"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Menaxho hapësirën"</string>
    <string name="filter" msgid="2018011724373033887">"Filtro"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Zgjidh opsionet e filtrit"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Të gjitha"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Çaktivizuar"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Të shkarkuara"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Vrapim"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Hapësira ruajtëse e USB-së"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Në kartën SD"</string>
    <string name="disabled" msgid="9206776641295849915">"Çaktivizuar"</string>
    <string name="not_installed" msgid="2797554494953450291">"Nuk është i instaluar për këtë përdorues"</string>
    <string name="no_applications" msgid="7336588977497084921">"Asnjë aplikacion."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Hapësira e brendshme ruajtëse"</string>
    <string name="internal_storage_sentence" msgid="889098931914857143">"hapësira e brendshme për ruajtje"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Hapësira USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Hapësira SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Po llogarit përsëri madhësinë…"</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Të fshihen të dhënat e aplikacionit?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Të gjitha të dhënat e këtij aplikacioni do të fshihen përgjithmonë. Kjo përfshin të gjithë skedarët, cilësimet, llogaritë, bazat e të dhënave etj."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"Në rregull"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Anulo"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Aplikacioni nuk u gjet në listën e aplikacioneve të instaluara."</string>
    <string name="clear_data_failed" msgid="7214074331627422248">"Nuk mundi të fshinte të dhënat e aplikacionit."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Pastro të dhënat"</string>
    <string name="clear_failed_dlg_text" msgid="5464475937929941008">"Nuk mundi të fshinte të dhënat për aplikacionin."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Ky aplikacion mund të qaset në tabletin tënd si më poshtë:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Ky aplikacion mund të ketë qasje te të mëposhtmet në telefon:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Ky aplikacion mund të ketë qasje në tablet, sikurse më poshtë. Për të përmirësuar cilësinë e funksionimit dhe për të zvogëluar përdorimin e memories, disa nga këto leje mundësohen te aplikacioni <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, pasi ai ekzekutohet sipas të njëjtit proces sikurse <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Ky aplikacion mund të ketë qasje te të mëposhtmet në telefon. Në mënyrë që të përmirësohet performanca dhe të reduktohet përdorimi i memories, disa nga këto leje ofrohen për <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, sepse punon në të njëjtin proces si <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> dhe <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> dhe <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Ky aplikacion mund të shkaktojë tarifa shtesë:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Dërgo SMS \"premium\""</string>
    <string name="computing_size" msgid="1599186977475211186">"Po llogarit…"</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Madhësia e paketës nuk mund të llogaritej."</string>
    <string name="empty_list_msg" msgid="3552095537348807772">"Nuk ke ndonjë aplikacion të palëve të treta të instaluar."</string>
    <string name="version_text" msgid="9189073826278676425">"versioni <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Zhvendos"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Zhvendos te tableti"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Zhvendos te telefoni"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Zhvendose në USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Zhvendos te karta SD"</string>
    <string name="moving" msgid="6431016143218876491">"Po zhvendos"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Një migrim tjetër është tashmë në vazhdim."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nuk ka hapësirë ruajtëse të mjaftueshme."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"Aplikacioni nuk ekziston."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplikacioni është i mbrojtur kundër kopjimit."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Vendndodhja e instalimit nuk është e vlefshme."</string>
    <string name="system_package" msgid="1352722848400644991">"Përditësimet e sistemit nuk mund të instalohen në median e jashtme."</string>
    <string name="move_error_device_admin" msgid="8148342933314166497">"Administratori i pajisjes nuk mund të instalohet në pajisje të jashtme."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Të ndalohet me forcë?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Nëse e ndalon me forcë një aplikacion, ai mund të përjetojë çrregullime në funksionim."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="187885379493011720">"Nuk mundi të zhvendoste aplikacionin. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Vendndodhja e preferuar e instalimit"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Ndrysho vendndodhjen e preferuar të instalimit për aplikacione të reja"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Të çaktivizohet aplikacioni i integruar?"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Çaktivizo aplikacionin"</string>
    <string name="app_disable_dlg_text" msgid="7824930380425568584">"Nëse e çaktivizon këtë aplikacion, aplikacionet e tjera mund të mos funksionojnë më siç pritet."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Të fshihen të dhënat dhe të çaktivizohet aplikacioni?"</string>
    <string name="app_special_disable_dlg_text" msgid="1007112763234313018">"Nëse e çaktivizon këtë aplikacion, aplikacionet e tjera mund të mos funksionojnë më siç pritet. Të dhënat e tua do të fshihen po ashtu."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Të çaktivizohen njoftimet?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Nëse i çaktivizon njoftimet për këtë aplikacion, mund të humbasësh alarme dhe përditësime të rëndësishme."</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Dyqani"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Detajet e aplikacioneve"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Aplikacioni i instaluar nga <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Operacionet e aplikacionit"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Në funksionim"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nuk përdoret asnjëherë)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Asnjë apl. i parazgjedhur"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Përdorimi i hapësirës ruajtëse"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Shiko hapësirën për ruajtje të përdorur nga aplikacionet"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Po rinis..."</string>
    <string name="cached" msgid="1059590879740175019">"Procesi në sfond i ruajtur në memorien specifike"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nuk po ekzekutohet asgjë."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"U nis nga aplikacioni."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> të lira"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> përdorur"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Përdoruesi: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Përdorues i hequr"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbim"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbime"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procese dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbim"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procese dhe <xliff:g id="NUMSERVICES">%2$d</xliff:g> shërbime"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Memoria e pajisjes"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Përdorimi i RAM-it nga aplikacionet"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sistemi"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikacionet"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"E lirë"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Në përdorim"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"Në memorien specifike"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> nga RAM-i"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Aplikacioni në ekzekutim"</string>
    <string name="no_services" msgid="7133900764462288263">"Jo aktiv"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Shërbimet"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Proceset"</string>
    <string name="service_stop" msgid="6369807553277527248">"Ndalo"</string>
    <string name="service_manage" msgid="1876642087421959194">"Cilësimet"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Ky shërbim u nis nga aplikacioni i vet. Ndalimi i tij mund të shkarkojë dështimin e aplikacionit."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Ky aplikacion nuk mund të ndalohet në mënyrë të sigurt. Nëse e ndalon, mund të humbësh disa nga puna jote aktuale."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"Ky është një proces i vjetër i aplikacionit që po vazhdon të ekzekutohet për çdo rast nëse nevojitet sërish. Zakonisht nuk ka arsye për ta ndaluar."</string>
    <string name="service_manage_description" msgid="479683614471552426">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: aktualisht në përdorim. Trokit te \"Cilësimet\" për ta kontrolluar."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Procesi kryesor është në përdorim."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Shërbimi <xliff:g id="COMP_NAME">%1$s</xliff:g> është në përdorim."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Ofruesi <xliff:g id="COMP_NAME">%1$s</xliff:g> është në përdorim."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Të ndalohet shërbimi i sistemit?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Nëse e ndalon këtë shërbim, disa funksione të tabletit tënd mund të mos punojnë më si duhet, deri sa ta fikësh dhe më pas ta ndezësh përsëri."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Nëse e ndalon këtë shërbim, disa funksione të telefonit tënd mund të mos punojnë më si duhet deri sa ta fikësh dhe më pas ta ndezësh përsëri."</string>
    <string name="language_settings" msgid="8758655933029560944">"Gjuhët dhe të dhënat"</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Gjuhët dhe të dhënat"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tastiera dhe metodat e hyrjes"</string>
    <string name="phone_language" msgid="7116581601133118044">"Gjuhët"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Zëvendëso automatikisht"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Korrigjo fjalët e shkruara gabim"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Kapitalizim automatik"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Filloji fjalitë me shkronjë të madhe"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Vendos automatikisht pikësimin"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Cilësimet e tastierës fizike"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Shtyp dy herë tastin Hapësirë për të futur \".\""</string>
    <string name="show_password" msgid="3001113966880559611">"Bëji fjalëkalimet të dukshme"</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="spellchecker_security_warning" msgid="9060897418527708922">"Ky kontrollues germëzimi mund të jenë në gjendje të mbledhë të gjithë tekstin që shkruan, përfshirë të dhëna personale si fjalëkalime dhe numra kartash krediti. Kjo vjen nga aplikacioni <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Të përdoret ky kontrollues germëzimi?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Cilësimet"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Gjuha"</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="keyboard_and_input_methods_category" msgid="212319666432360385">"Tastiera dhe mënyrat e hyrjes"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Tastiera virtuale"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Tastiera virtuale e disponueshme"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Menaxho tastierat"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Asistenca e tastierës"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Tastiera fizike"</string>
    <string name="show_ime" msgid="2658582193437188227">"Shfaq tastierën virtuale"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Mbaje në ekran ndërsa tastiera fizike është aktive"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Ndihmësi i shkurtoreve të tastierës"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Shfaq shkurtoret e disponueshme"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"E parazgjedhur"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Miu/blloku i prekjes"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Shpejtësia e treguesit"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Kontrolluesi i lojës"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Përdor dridhësin"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Ridrejtoje dridhësin te kontrolluesi i lojës kur të lidhet."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Zgjidh planin e tastierës"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Konfiguro planet e tastierës"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Për kalimin, shtyp \"Kontroll\" dhe \"Hapësirë\""</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"E parazgjedhur"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Planet e tastierës"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Fjalori personal"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Shto"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Shto në fjalor"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Opsione të tjera"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Më pak opsione"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"Në rregull"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Fjala:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Shkurtorja:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Gjuha:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Shkruaj një fjalë"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Shkurtore opsionale"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Redakto fjalën"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Redakto"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Fshi"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"Nuk ke asnjë fjalë në fjalorin e përdoruesit. Për të shtuar një fjalë, trokit te butoni Shto (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Për të gjitha gjuhët"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Gjuhë të tjera…"</string>
    <string name="testing" msgid="6584352735303604146">"Testimi"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informacion për tabletin"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informacioni i telefonit"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Hyrjet e tekstit"</string>
    <string name="input_method" msgid="5434026103176856164">"Metoda e hyrjes"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Tastiera aktuale"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Fut përzgjedhësin e metodës"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatik"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Shfaq gjithmonë"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Fshih gjithmonë"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Konfiguro metodat e hyrjes"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Cilësimet"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Cilësimet"</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="input_methods_settings_label_format" msgid="6002887604815693322">"Cilësimet e <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Zgjidh metodat aktive të hyrjes"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Cilësimet e tastierës në ekran"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Tastiera fizike"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Cilësimet e tastierës fizike"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Zgjidh veglën"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Zgjidh miniprogramin"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Të krijohet miniaplikacion dhe të lejohet qasja në të?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Pasi të krijosh miniaplikacionin, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> mund të qaset te të gjitha të dhënat që shfaq ai."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Lejo gjithmonë që <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> të krijojë miniaplikacione dhe të ketë qasje te të dhënat e tyre"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> ditë <xliff:g id="HOURS">%2$d</xliff:g> orë <xliff:g id="MINUTES">%3$d</xliff:g> min. <xliff:g id="SECONDS">%4$d</xliff:g> sek."</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> orë <xliff:g id="MINUTES">%2$d</xliff:g> min. <xliff:g id="SECONDS">%3$d</xliff:g> sek."</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> minuta <xliff:g id="SECONDS">%2$d</xliff:g> sekonda"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> sek."</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> ditë <xliff:g id="HOURS">%2$d</xliff:g> orë <xliff:g id="MINUTES">%3$d</xliff:g> minuta"</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> orë <xliff:g id="MINUTES">%2$d</xliff:g> minuta"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min."</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistikat e përdorimit"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistikat e përdorimit"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Rendit sipas:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacioni"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Përdorur për herë të fundit"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Koha e përdorimit"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Qasshmëria"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Cilësimet e qasjes"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Cilësimet e shikimit"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"Mund ta personalizosh këtë pajisje për t\'iu përshtatur nevojave të tua. Këto funksione të qasjes mund të ndryshohen më vonë te \"Cilësimet\"."</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Shërbimet"</string>
    <string name="talkback_title" msgid="7912059827205988080">"Talkback"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Një lexues i ekranit kryesisht për personat e verbër dhe me shikim të dobët"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Sistemi"</string>
    <string name="accessibility_display_title" msgid="7610175687949675162">"Paraqitja"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Titrat"</string>
    <string name="accessibility_screen_magnification_title" msgid="9002237235486714636">"Gjesti i zmadhimit"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Trokit 3 herë për ta zmadhuar"</string>
    <string name="accessibility_screen_magnification_summary" msgid="7798920976388197258"><b>"Për të zmadhuar"</b>", trokit me shpejtësi tek ekrani 3 herë me një gisht.\n"<ul><li>"Zvarrit 2 ose më shumë gishta për të lëvizur"</li>\n<li>"Afro bashkë 2 ose më shumë gishta ose largoji nga njëri-tjetri për të përshtatur zmadhimin"</li></ul>\n\n<b>"Për të zmadhuar përkohësisht"</b>", trokit me shpejtësi tek ekrani 3 herë dhe mbaje të shtypur me gisht në trokitjen e tretë.\n"<ul><li>"Zvarrite gishtin për të lëvizur nëpër ekran"</li>\n<li>"Ngrije gishtin për ta zvogëluar"</li></ul>\n\n"Nuk mund të zmadhosh te tastiera dhe te shiriti i navigimit."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Shkurtore për qasshmërinë"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Aktivizuar"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Çaktivizuar"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="1605107799571936715">"Kur ky funksion është i aktivizuar, mund të aktivizosh me shpejtësi funksionet e qasjes në dy hapa:\n\nHapi 1: Mbaj të shtypur butonin e energjisë deri sa të dëgjosh një tingull ose të ndjesh një dridhje.\n\nHapi 2: Trokit dhe mbaj me dy gishta deri sa të dëgjosh konfirmimin e audios.\n\nNëse pajisja ka shumë përdorues, përdorimi i kësaj shkurtoreje në ekranin e kyçjes aktivizon përkohësisht qasjen deri sa pajisja të shkyçet."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Tekst me kontrast të lartë"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Përditëso auto. zmadhimin e ekranit"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Përditëso zmadhimin e ekranit në kalimet e apl."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Butoni i fikjes mbyll telefonatën"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Thuaji fjalëkalimet me zë"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Kursor i madh miu"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Audioja mono"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Ndërthur kanalet kur luan audion"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Vonesa e prekjes dhe e mbajtjes shtypur"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Kthimi i ngjyrës"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="8658240868230680912">"(Eksperimentale) Mund të ndikojë në veprimtari"</string>
    <string name="accessibility_autoclick_preference_title" msgid="7014499339068449623">"Kliko pasi kursori të ndalojë së lëvizuri"</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Vonesa përpara klikimit"</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Shfaq në Cilësimet e shpejta"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Modaliteti i korrigjimit"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="other">Vonesë jashtëzakonisht e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë jashtëzakonisht e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="other">Vonesë shumë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë shumë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="other">Vonesë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë e shkurtër (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="other">Vonesë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="other">Vonesë shumë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Vonesë shumë e gjatë (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Cilësimet"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Aktivizuar"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Çaktivizuar"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Shikim paraprak"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Opsionet standarde"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Gjuha"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Madhësia e tekstit"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Stili i titrave"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Personalizo opsionet"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Ngjyra e sfondit"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Niveli i transparencës së sfondit"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Ngjyra e dritares së titrave"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Transparenca e dritares së titrave"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Ngjyra e tekstit"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Niveli i transparencës së tekstit"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Ngjyra e skajit"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Lloji i skajeve"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Familja e shkrimit"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Titrat do të duken kështu"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"E parazgjedhur"</string>
    <string name="color_title" msgid="4258931051732243983">"Ngjyra"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"E parazgjedhur"</string>
    <string name="color_none" msgid="3475640044925814795">"Asnjë"</string>
    <string name="color_white" msgid="8045195170201590239">"E bardhë"</string>
    <string name="color_gray" msgid="9192312087142726313">"Gri"</string>
    <string name="color_black" msgid="7517353520909872561">"E zezë"</string>
    <string name="color_red" msgid="4949354900304125428">"E kuqe"</string>
    <string name="color_green" msgid="5537717328428845841">"E gjelbër"</string>
    <string name="color_blue" msgid="7731984529016953223">"E kaltër"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Gurkali"</string>
    <string name="color_yellow" msgid="9112680561610873529">"E verdhë"</string>
    <string name="color_magenta" msgid="5059212823607815549">"E purpurt"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Të përdoret \"<xliff:g id="SERVICE">%1$s</xliff:g>\"?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"\"<xliff:g id="SERVICE">%1$s</xliff:g>\" ka nevojë të:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Duke qenë se një aplikacion po bllokon një kërkesë për leje, \"Cilësimet\" nuk mund të verifikojnë përgjigjen tënde."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Nëse aktivizon <xliff:g id="SERVICE">%1$s</xliff:g>, pajisja nuk do të përdorë kyçjen e ekranit për të rritur enkriptimin e të dhënave."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Për shkak se ke aktivizuar shërbimin e qasshmërisë, pajisja jote nuk do të përdorë kyçen e ekranit për përmirësimin e enkriptimit të të dhënave."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Meqenëse aktivizimi i <xliff:g id="SERVICE">%1$s</xliff:g> ndikon në enkriptimin e të dhënave, duhet të konfirmosh motivin tënd."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Duke qenë se aktivizimi i <xliff:g id="SERVICE">%1$s</xliff:g> ndikon në enkriptimin e të dhënave, duhet të konfirmosh kodin PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Meqenëse aktivizimi i <xliff:g id="SERVICE">%1$s</xliff:g> ndikon në enkriptimin e të dhënave, duhet të konfirmosh fjalëkalimin tënd."</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Vëzhgojë veprimet e tua"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="6640333613848713883">"Merr njoftime kur je duke ndërvepruar me një aplikacion."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Të ndalohet shërbimi \"<xliff:g id="SERVICE">%1$s</xliff:g>\"?"</string>
    <string name="disable_service_message" msgid="2247101878627941561">"Trokitja te \"Në rregull\" do të ndalojë shërbimin <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nuk është instaluar asnjë shërbim"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nuk është dhënë asnjë përshkrim."</string>
    <string name="settings_button" msgid="3006713718908152930">"Cilësimet"</string>
    <string name="print_settings" msgid="4742428530112487843">"Printimi"</string>
    <plurals name="print_settings_title" formatted="false" msgid="6994238166067938432">
      <item quantity="other">%d punë printimi</item>
      <item quantity="one">1 punë printimi</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Shërbimet e printimit"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nuk është instaluar asnjë shërbim"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nuk u gjet asnjë printer"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Cilësimet"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Shto printerë"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Aktivizuar"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Çaktivizuar"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Shto shërbim"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Shto printer"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Kërko"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Po kërkon për printerë"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Shërbimi është çaktivizuar"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Punët e printimit"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Punë printimi"</string>
    <string name="print_restart" msgid="8373999687329384202">"Rifillo"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Anulo"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Po printon <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Po anulon <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Gabim i printerit për <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Printeri bllokoi <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Kutia e kërkimit është e shfaqur"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Kutia e kërkimit është e fshehur"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Më shumë informacione mbi këtë printer"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Bateria"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Kush e ka harxhuar baterinë"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Të dhënat nuk ofrohen."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"<xliff:g id="REMAIN">%1$s</xliff:g> të mbetura"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> për të ngarkuar"</string>
    <string name="power_usage_list_summary" msgid="2409288197839512482">"Përdorimi nga ngarkimi i fundit i plotë"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Përdorimi i baterisë që nga heqja nga ngarkimi"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Përdorimi i baterisë që nga rivendosja"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> me bateri"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> që nga heqja nga priza"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Ngarkimi"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Qëndrimi aktiv i ekranit"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS-ja aktive"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Kamera aktive"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Blici aktiv"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Qëndrimi zgjuar"</string>
    <string name="battery_stats_phone_signal_label" msgid="3537569115723850618">"Sinjali i rrjetit celular"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Koha e zgjimit të pajisjes"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Koha e aktivizimit të Wi‑Fi"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Koha e aktivizimit të Wi‑Fi"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Detajet e historikut"</string>
    <string name="details_title" msgid="3792801565213935385">"Përdor detajet"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Përdor detajet"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Rregullo përdorimin e energjisë"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Paketat e përfshira"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ekrani"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Blici"</string>
    <string name="power_camera" msgid="4976286950934622605">"Kamera"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth-i"</string>
    <string name="power_cell" msgid="6596471490976003056">"Rrjeti celular në gatishmëri"</string>
    <string name="power_phone" msgid="5392641106474567277">"Telefonatat zanore"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tableti në gjendje joaktive"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefoni në gjendje joaktive"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Të ndryshme"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Numëruar më shumë sa duhet"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"CPU-ja në total"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU-ja në plan të parë"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Mbaje të zgjuar"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi‑Fi në ekzekutim"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tableti"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefoni"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Paketat celulare të dërguara"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Paketat celulare u morën"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Radioja celulare është aktive"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Paketat e Wi‑Fi u dërguan"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Paketat e Wi‑Fi u morën"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Kamera"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Blici"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Koha e lënies ndezur"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Koha pa sinjal"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Kapaciteti total i baterisë"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Përdorimi i llogaritur i energjisë"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Përdorimi i vërejtur i energjisë"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Ndalo me forcë"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informacioni i apl."</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Cilësimet e apl."</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Cilësimet e ekranit"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Cilësimet e Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Cilësimet e Bluetooth-it"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Bateria e përdorur nga telefonatat zanore"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Bateria e përdorur kur tableti nuk është në punë"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Bateria e përdorur kur telefoni nuk është në punë"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Bateria e përdorur nga radioja celulare"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Kalo te modaliteti \'në aeroplan\" për të kursyer energjinë në zonat pa mbulim të rrjetit celular"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Bateria e përdorur nga blici"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Bateria e përdorur nga kamera"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Bateria e përdorur nga ekrani dhe drita e sfondit"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Ul ndriçimin e ekranit dhe/ose kohën e fikjes së tij"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Bateria e përdorur nga Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Çaktivizo Wi‑Fi kur nuk e përdor ose kur nuk ofrohet"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Bateria e përdorur nga Bluetooth-i"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Çaktivizo \"Bluetooth-in\" kur nuk e përdor."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Provo të lidhesh me një pajisje tjetër me \"Bluetooth\""</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Bateria e përdorur nga aplikacioni"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Ndalo ose çinstalo aplikacionin"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Përzgjidh modalitetin e kursimit të baterisë"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacioni mund të ofrojë cilësimet për të zvogëluar përdorimin e baterisë"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Bateria e përdorur nga përdoruesi"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Përdorime të ndryshme të energjisë"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Përdorimi i baterisë është një llogaritje e përafërt e përdorimit të energjisë dhe nuk përfshin çdo burim të shkarkimit të baterisë. \"Të ndryshme\" nënkupton ndryshimin midis përdorimit të llogaritur në mënyrë të përafërt të energjisë dhe shkarkimit aktual të vërejtur në bateri."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Përdorimi i energjisë i numëruar më shumë sa duhet"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> që kur ka qenë në prizë"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Kur ishte në prizë për herë të fundit për <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Totalet e përdorimit"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Rifresko"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Sistemi operativ Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Serveri i medias"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimizimi i aplikacionit"</string>
    <string name="battery_saver" msgid="1426682272004907982">"Kursyesi i baterisë"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Aktivizim automatikisht"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Asnjëherë"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="7536784431655058267">"në nivelin e baterisë %1$s"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistikat e procesit"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Statistikat teknike për proceset në ekzekutim"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Përdorimi i memories"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"<xliff:g id="USEDRAM">%1$s</xliff:g> nga <xliff:g id="TOTALRAM">%2$s</xliff:g> të përdorura gjatë <xliff:g id="TIMEDURATION">%3$s</xliff:g> të fundit"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"<xliff:g id="PERCENT">%1$s</xliff:g> e memories RAM është përdorur për <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Sfondi"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Plani i parë"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Në memorien specifike"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"Sistemi operativ Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Vendas"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Bërthamë"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Memoriet specifike"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Përdorimi i RAM-it"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Përdorimi i RAM-it (sfond)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Koha në funksionim"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Përpunime"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Shërbimet"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Kohëzgjatja"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Detajet e memories"</string>
    <string name="mem_state_subtitle" msgid="2407238869781011933">"Gjendjet e memories"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Përdorimi i memories"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Bërthamë"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Origjinal"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Memoria specifike e bërthamës"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"Ndërrimi i ZRam-it"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"E lirë"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Totali"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 orë"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 orë"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 orë"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 ditë"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Shfaq sistemin"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Fshih sistemin"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Tregoji në përqindje"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Përdor Uss-në"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Lloji i statistikave"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Sfondi"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Në plan të parë"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Në memorien specifike"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Hyrjet dhe daljet e zërit"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Cilësimet e hyrjes dhe daljes së zërit"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Kërkimi me zë"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Tastierë për \"Android\""</string>
    <string name="voice_category" msgid="1430370497125803904">"Ligjërimi"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Cilësimet e hyrjes zanore"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Të dhënat zanore"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Shërbime të hyrjes zanore"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Ndërveprimi dhe fjalëkyçi i aktivizimit (hotword), i plotë"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Shërbim i thjeshtë \"ligjërim-në-tekst\""</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Ky shërbim i hyrjes së zërit do të kryejë gjithmonë monitorim të zërit si dhe do të kontrollojë në emrin tënd, të gjitha aplikacionet që mundësohen me zë. Ai ofrohet nga aplikacioni <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Të aktivizohet përdorimi e këtij shërbimi?"</string>
    <string name="tts_reset_speech_rate_title" msgid="3993885027390495498">"Rivendos shpejtësinë e të folurit"</string>
    <string name="tts_reset_speech_rate_summary" msgid="8561618897094097540">"Rivendose në normale shpejtësinë e të folurit."</string>
    <string name="gadget_title" msgid="5519037532720577836">"Kontrolli i energjisë"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Po përditëson cilësimin e Wi‑Fi"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Po përditëson cilësimin e \"Bluetooth-it\""</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"aktivizuar"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"çaktivizuar"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"po aktivizon"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"po çaktivizon"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi‑Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth-i"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Vendndodhja"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sinkronizo"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Ndriçimi <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automatike"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"i plotë"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"gjysmë"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"çaktivizuar"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Ruajtja e kredencialeve"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instalo nga hapësira ruajtëse"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instalo nga karta SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Instalo certifikatat nga hapësira ruajtëse"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Instalo certifikatat nga karta SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Pastro kredencialet"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Hiqi të gjitha certifikatat"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Kredencialet e besuara"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Shfaq certifikatat CA të besuara"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Kredencialet e përdoruesit"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Shiko dhe modifiko kredencialet e ruajtura"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Të përparuara"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Lloji i hapësirës ruajtëse"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"E mbështetur nga hardueri"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Vetëm ajo e softuerit"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Kredencialet nuk ofrohen për këtë përdorues"</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Shkruaj fjalëkalimin për hapësirën ruajtjëse të kredencialeve."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Fjalëkalimi aktual:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Të hiqen të gjitha përmbajtjet?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Fjalëkalimi duhet të ketë të paktën 8 karaktere."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Fjalëkalim i pasaktë."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Fjalëkalim i pasaktë. Ke edhe një mundësi tjetër para se hapësira ruajtëse e kredencialeve të fshihet."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Fjalëkalim i pasaktë. Ke edhe <xliff:g id="NUMBER">%1$d</xliff:g> mundësi të tjera para se hapësira ruajtëse e kredencialeve të spastrohet."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Hapësira ruajtëse e kredencialeve është spastruar."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Ruajtja e kred. s\'mund të fshihej."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Është aktivizuar hapësira për ruajtjen e kredencialeve."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Duhet të caktosh një PIN të ekranit të kyçjes para se të mund të përdorësh hapësirën ruajtëse të kredencialeve."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Aplikacionet me qasje përdorimi"</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Toni i urgjencës"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Cakto sjelljen kur kryhet një telefonatë urgjence"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Krijimi i rezervës dhe rivendosja"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Rezervo dhe rivendos"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Rezervo dhe restauro"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Të dhënat personale"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Rezervo të dhënat e mia"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Rezervo të dhënat e aplikacioneve, fjalëkalimet e Wi-Fi dhe cilësimet e tjera në serverët e Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Llogaria rezervë"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Përfshi të dhënat e aplikacionit"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Restaurimi automatik"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Në rast të ri-instalimit të një aplikacioni, cilësimet dhe të dhënat e rezervuara do të restaurohen"</string>
    <string name="backup_inactive_title" msgid="5355557151569037197">"Shërbimi i rezervimit është joaktiv."</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Asnjë llogari nuk po ruan aktualisht të dhënat e kopjes rezervë"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Të ndalohet rezervimi i fjalëkalimeve të Wi-Fi, faqeshënuesve, të dhënave të aplikacioneve dhe cilësimeve të tjera? Të fshihen gjithashtu edhe të gjitha kopjet në serverët e Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Ndalo rezervimin e të dhënave të pajisjes (si p.sh. fjalëkalimet e Wi-Fi dhe historikun e telefonatave) dhe të dhënave të aplikacioneve (si p.sh. cilësimet dhe skedarët e ruajtur nga aplikacionet) dhe spastro të gjitha kopjet në serverët në largësi?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Rezervo automatikisht në largësi të dhënat e pajisjes (si p.sh. fjalëkalimet e Wi-Fi dhe historikun e telefonatave) dhe të dhënat e aplikacioneve (si p.sh. cilësimet dhe skedarët e ruajtur nga aplikacionet).\n\nKur aktivizon rezervimin automatik, të dhënat e pajisjes dhe të aplikacioneve ruhen periodikisht në largësi. Të dhënat e aplikacioneve mund të jenë çdo e dhënë që ka ruajtur një aplikacion (bazuar në cilësimet e zhvilluesit), duke përfshirë të dhëna ndoshta delikate si kontaktet, mesazhet dhe fotografitë."</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Cilësimet e administrimit të pajisjes"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Administratori i pajisjes"</string>
    <string name="remove_device_admin" msgid="7736174723276745230">"Çaktivizoje këtë administrator të pajisjes"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Çinstalo aplikacionin"</string>
    <string name="remove_and_uninstall_device_admin" msgid="6983421266937728520">"Çativizo dhe çinstalo"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Administratorët e pajisjes"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Nuk mundësohet asnjë administrator pajisjeje"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Personal"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Punë"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Nuk mundësohet asnjë agjent i besuar"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Të aktivizohet administratori i pajisjes?"</string>
    <string name="add_device_admin" msgid="1349673618141610506">"Aktivizo këtë administrator të pajisjes"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Administratori i pajisjes"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Aktivizimi i këtij administratori do të lejojë që aplikacioni \"<xliff:g id="APP_NAME">%1$s</xliff:g>\" të kryejë veprimet e mëposhtme:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Ky administrator është aktiv dhe lejon aplikacionin <xliff:g id="APP_NAME">%1$s</xliff:g> të kryejë operacionet vijuese:"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Të aktivizohet menaxheri i profilit?"</string>
    <string name="adding_profile_owner_warning" msgid="8081841501073689534">"Duke vazhduar, Përdoruesi yt do të menaxhohet nga Administratori yt, i cili mund të ruajë të dhëna të lidhura përveç të dhënave të tua personale.\n\nAdministratori yt ka aftësinë të monitorojë dhe të menaxhojë cilësimet, qasjen, aplikacionet dhe të dhënat e lidhura me këtë Përdorues, duke përfshirë aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes tënde."</string>
    <string name="admin_disabled_other_options" msgid="4564776259414246934">"Opsionet e tjera janë çaktivizuar nga administratori yt."</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Më shumë detaje"</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Pa titull"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Të përgjithshme"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Regjistri i njoftimeve"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Zilja dhe dridhja e telefonit."</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Sistemi"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Konfigurimi i Wi‑Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Lidhu me rrjetin Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Po lidhet me rrjetin Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>…"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"U lidh me rrjetin Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Shto një rrjet"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Nuk është e lidhur"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Shto një rrjet"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Rifresko listën"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Kapërce"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Përpara"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Prapa"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Detajet e rrjetit"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Lidhu"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Harro"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Ruaj"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Anulo"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Po skanon rrjetet…"</string>
    <string name="wifi_setup_status_select_network" msgid="3960480613544747397">"Trokit te një rrjet për t\'u lidhur me të"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Lidhu me rrjet ekzistues"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Lidhu me rrjet të pasigurt"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Shkruaj konfigurimin e rrjetit"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Lidhu me një rrjet të ri"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Po lidhet..."</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Shko te hapi tjetër"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="6796317704783144190">"EAP nuk mbështetet."</string>
    <string name="wifi_setup_eap_not_supported" msgid="6812710317883658843">"Nuk mund të konfigurosh një lidhje Wi-Fi EAP gjatë konfigurimit. Pas konfigurimit, mund ta bësh këtë te Cilësimet &gt; Rrjetet dhe pa tel."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Lidhja mund të zgjasë disa minuta..."</string>
    <string name="wifi_setup_description_connected" msgid="6649168170073219153">"Trokit te "<b>"Përpara"</b>" për të vazhduar me konfigurimin.\n\nTrokit "<b>"Prapa"</b>" për t\'u lidhur me një rrjet tjetër Wi‑Fi."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinkronizimi u aktivizua"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sinkronizimi u çaktivizua"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Po sinkronizon tani"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Gabim në sinkronizim."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinkronizimi dështoi"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinkronizimi është aktiv"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinkronizo"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sinkronizimi ka aktualisht probleme. Do të ofrohet sërish së shpejti."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Shto një llogari"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Profili i punës nuk ofrohet ende"</string>
    <string name="work_mode_label" msgid="5794470908668593961">"Modaliteti i punës"</string>
    <string name="work_mode_summary" msgid="1620246003886940776">"Lejoje profilin e punës të funksionojë, duke përfshirë aplikacionet, sinkronizimin në sfond dhe funksionet e lidhura"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Hiq profilin e punës"</string>
    <string name="background_data" msgid="5779592891375473817">"Të dhënat në sfond"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacionet mund të sinkronizojnë, dërgojnë dhe marrin të dhëna në çdo kohë"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Të çaktivizohen të dhënat në sfond?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Ҫaktivizimi i të dhënave në sfond zgjat jetëgjatësinë e baterisë dhe zvogëlon përdorimin e të dhënave. Disa aplikacione mund të përdorin akoma lidhjen e të dhënave në sfond."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Auto-sinkronizo të dhënat e apl."</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sinkronizimi është aktiv"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sinkronizimi është JOAKTIV"</string>
    <string name="sync_error" msgid="5060969083117872149">"Gabim gjatë sinkronizimit"</string>
    <string name="last_synced" msgid="4242919465367022234">"Sinkronizuar për herë të fundit <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Po sinkronizon tani…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Cilësimet e rezervimit"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Rezervo cilësimet e mia"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinkronizo tani"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Anulo sinkronizimin"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Trokit për ta sinkronizuar tani<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendari"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontaktet"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Mirë se erdhe në sinkronizimin e Google!"</font>" \nNjë metodë e Google për të sinkronizuar të dhënat për të të lejuar qasje te kontaktet, takimet dhe të tjera, kudo ku të ndodhesh."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Cilësimet e sinkronizimit të apl."</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Të dhënat dhe sinkronizimi"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Ndërro fjalëkalimin"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Cilësimet e llogarisë"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Hiq llogarinë"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Shto një llogari"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Përfundo"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Të hiqet llogaria?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Heqja e kësaj llogarie do të fshijë të gjitha mesazhet, kontaktet dhe të dhëna të tjera të saj nga tableti!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Heqja e kësaj llogarie do të fshijë nga telefoni të gjitha mesazhet dhe kontaktet e saj, si dhe të dhëna të tjera!"</string>
    <string name="remove_account_failed" msgid="6980737964448187854">"Ky ndryshim nuk lejohet nga administratori yt"</string>
    <string name="provider_label" msgid="7724593781904508866">"Abonimet me shtytje"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Nuk mund të sinkronizojë manualisht"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Sinkronizimi për këtë artikull është aktualisht i çaktivizuar. Për ta ndryshuar këtë cilësim, aktivizo përkohësisht të dhënat në sfond dhe sinkronizimin automatik."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Adresa 4G MAC"</string>
    <string name="enter_password" msgid="8035706727471334122">"Për të nisur Androidin, fut fjalëkalimin"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Për të nisur Androidin, fut kodin PIN"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Për të nisur Androidin, vizato motivin tënd"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Motivi është i gabuar"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Fjalëkalim i gabuar"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Kod PIN i gabuar"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Po kontrollon..."</string>
    <string name="starting_android" msgid="4001324195902252681">"Po nis Android..."</string>
    <string name="delete" msgid="4219243412325163003">"Fshi"</string>
    <string name="misc_files" msgid="6720680815969643497">"Skedarë të ndryshëm"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"u zgjodhën <xliff:g id="NUMBER">%1$d</xliff:g> nga <xliff:g id="TOTAL">%2$d</xliff:g> në total"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> nga <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Përzgjidhi të gjtiha"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Përdorimi i të dhënave"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Përdorimi i të dhënave"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga ajo e pajisjes tënde."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Përdorimi i aplikacionit"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFORMACIONI I APL."</string>
    <string name="data_usage_cellular_data" msgid="4859424346276043677">"Të dhënat celulare"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Cakto kufirin e të dhënave"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cikli i përdorimit të të dhënave"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Përdorimi i aplikacionit"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Të dhënat në roaming"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Kufizo të dhënat në sfond"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Lejo të dhënat në sfond"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Përdorimi i 4G i ndarë"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Shfaq Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Fshih Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Shfaq përdorimin e Eternetit"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Fshih përdorimin e eternetit"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Kufizimet e rrjetit"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Të dhënat e autosinkronizimit"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"Kartat SIM"</string>
    <string name="data_usage_menu_cellular_networks" msgid="5243515735055652279">"Rrjetet celulare"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"U ndërpre në kufi"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Auto-sinkronizo të dhënat"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Sinkronizo automatikisht të dhënat personale"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Sinkronizo automatikisht të dhënat e punës"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Ndrysho ciklin…"</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Dita për rivendosjen e ciklit të përdorimit të të dhënave:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Nuk janë përdorur të dhëna gjatë kësaj periudhe."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Plani i parë"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Sfondi"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"i kufizuar"</string>
    <string name="data_usage_disable_mobile" msgid="2613595056882494652">"Të çaktivizohen të dhënat celulare?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="3934211003105066167">"Kufizo të dhënat celulare"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Cakto kufirin e të dhënave 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Cakto kufirin për 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Cakto kufirin e të dhënave të Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Eternet"</string>
    <string name="data_usage_tab_mobile" msgid="2084466270343460491">"Celulare"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="7219011330831181312">"Celular"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Asnjë"</string>
    <string name="data_usage_enable_mobile" msgid="5900650720568852325">"Të dhënat celulare"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Të dhënat 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Të dhënat 4G"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Plani i parë:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Sfondi:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Cilësimet e apl."</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Të dhënat në sfond"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="4669789008211107454">"Aktivizo përdorimin e të dhënave celulare në sfond"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="1446565717342917727">"Për të kufizuar të dhënat në sfond për këtë aplikacion, në fillim cakto një kufi të të dhënave celulare."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Të kufizohen të dhënat në sfond?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5871168521456832764">"Ky funksion mund të shkaktojë që një aplikacion, i cili mbështetet në të dhënat në sfond, të mos punojë kur janë të disponueshme vetëm rrjetet celulare.\n\nMund të gjesh kontrolle më të përshtatshme për përdorimin e të dhënave në cilësimet që ofrohen brenda aplikacionit."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="1493134803720421674">"Kufizimi i të dhënave në sfond është i mundur vetëm kur ke caktuar një kufi të të dhënave celulare."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Të aktivizohen të dhënat e sinkronizimit automatik?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Çdo ndryshim që bën në llogaritë e tua në ueb do të kopjohet automatikisht te tableti.\n\nDisa llogari mund të kopjojnë po ashtu automatikisht çdo ndryshim që bën në tablet, për ta sinkronizuar në ueb. Kështu funksionon llogaria e Google."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Çdo ndryshim që bën në llogaritë e tua në ueb do të kopjohet automatikisht te telefoni.\n\nDisa llogari mund të kopjojnë po ashtu automatikisht çdo ndryshim që bën në telefon, për ta sinkronizuar në ueb. Kjo është mënyra se si funksionon llogaria e Google."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Të çaktivizohen të dhënat e sinkronizimit automatik?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"Ky funksion do të kursejë përdorimin e të dhënave dhe të baterisë, por për të mbledhur informacionet më të fundit, do të të duhet të sinkronizosh në mënyrë manuale çdo llogari. Nuk do të marrësh njoftime kur të ndodhin përditësimet."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Data e rivendosjes së ciklit të përdorimit"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Data e secilit muaj:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Cakto"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Cakto paralajmërimin për përdorimin e të dhënave"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Cakto kufirin e përdorimit të të dhënave"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Kufizimi i përdorimit të të dhënave"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="5788774061143636263">"Tableti do të çaktivizojë të dhënat celulare sapo të arrijë kufirin e caktuar.\n\nMeqenëse përdorimi i të dhënave matet nga tableti yt dhe operatori celular mund ta llogarisë ndryshe përdorimin, ki parasysh të vendosësh një kufi të menduar mirë."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3511301596446820549">"Telefoni yt do t\'i çaktivizojë të dhënat celulare kur të arrihet kufiri që ke caktuar.\n\nMeqenëse përdorimi i të dhënave matet nga telefoni yt dhe operatori celular mund ta llogarisë ndryshe përdorimin, ki parasysh të vendosësh një kufi të menduar mirë."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Të kufizohen të dhënat në sfond?"</string>
    <string name="data_usage_restrict_background" msgid="6264965779074729381">"Nëse i kufizon të dhënat celulare në sfond, disa aplikacione dhe shërbime nuk do të punojnë nëse nuk je i lidhur me Wi‑Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7954930300449415764">"Nëse i kufizon të dhënat celulare në sfond, disa aplikacione dhe shërbime nuk do të funksionojnë nëse nuk je i lidhur me Wi‑Fi.\n\nKy cilësim ndikon te të gjithë përdoruesit në këtë tablet."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="259958321968870600">"Nëse kufizon të dhënat celulare në sfond, disa aplikacione dhe shërbime nuk do të funksionojnë pa u lidhur me Wi-Fi. \n\nKy cilësim ndikon te të gjithë përdoruesit e këtij telefoni."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"paralajmërim"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039">"Kufiri "<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12"></font></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="data_usage_received_sent" msgid="5039699009276621757">"<xliff:g id="RECEIVED">%1$s</xliff:g> të marra, <xliff:g id="SENT">%2$s</xliff:g> të dërguara"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: rreth <xliff:g id="TOTAL">%1$s</xliff:g> të përdorura."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g>: rreth <xliff:g id="TOTAL">%1$s</xliff:g> të përdorura të matura nga tableti yt. Llogaritja e përdorimit të të dhënave të operatorit tënd mund të ndryshojë."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: rreth <xliff:g id="TOTAL">%1$s</xliff:g> të përdorura, siç është matur nga telefoni yt. Llogaritja e përdorimit të të dhënave nga operatori celular mund të ndryshojë."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Kufizimet e rrjetit"</string>
    <string name="data_usage_metered_body" msgid="3262343834446126044">"Rrjetet me konsum të kufizuar trajtohen sikurse rrjetet celulare ku të dhënat në sfond janë të kufizuara. Aplikacionet mund të të paralajmërojnë për shkarkime të mëdha, para se t\'i përdorësh këto rrjete."</string>
    <string name="data_usage_metered_mobile" msgid="2326986339431119372">"Rrjetet celulare"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Rrjetet Wi‑Fi me konsum të kufizuar"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Për të zgjedhur rrjetet me konsum të kufizuar, aktivizo Wi‑Fi."</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga ajo e pajisjes tënde."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Telefonata e urgjencës"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Kthehu te telefonata"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Emri"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Lloji"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa e serverit"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Enkriptimi PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Sekreti L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifikuesi IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Çelësi IPSec i parashkëmbyer"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Certifikata e përdoruesit IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certifikata CA e protokollit IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certifikata e serverit IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Shfaq opsionet e përparuara"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domenet e kërkimit të DNS-së"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Serverët DNS (p.sh. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Rrugët e transferimit (p.sh. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Emri i përdoruesit"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Fjalëkalimi"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Ruaj informacionet e llogarisë"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nuk përdoret)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(mos e verifiko serverin)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(marrë nga serveri)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Anulo"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Injoro"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Ruaj"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Lidh"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Zëvendëso"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Redakto profilin e VPN-së"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Harroje"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Lidhu me <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="2555877026824771115">"Shkëpute këtë VPN."</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Shkëpute"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Versioni <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Harroje rrjetin VPN"</string>
    <string name="vpn_replace_always_on_vpn_title" msgid="3010435028275752220">"Të zëvendësohet rrjeti ekzistues VPN?"</string>
    <string name="vpn_replace_always_on_vpn_message" msgid="4764679857158814028">"Je tashmë i lidhur me një rrjet VPN. Nëse je lidhur me një tjetër, rrjeti yt ekzistues VPN do të zëvendësohet."</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"<xliff:g id="VPN_NAME">%1$s</xliff:g> nuk mund të lidhet"</string>
    <string name="vpn_cant_connect_message" msgid="2593197919352621279">"Ky aplikacion nuk mbështet VPN-në që është gjithmonë aktive."</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Shto profil VPN-je"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Modifiko profilin"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Fshi profilin"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Rrjeti VPN gjithmonë aktiv"</string>
    <string name="vpn_no_vpns_added" msgid="4308317205962153438">"Nuk u shtua asnjë rrjet VPN."</string>
    <string name="vpn_always_on_active" msgid="2789423425184556882">"Gjithnjë aktiv është aktiv"</string>
    <string name="vpn_not_supported_by_this_app" msgid="5002053874215892179">"Nuk mbështetet nga ky aplikacion"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Zgjidh një profil VPN-je për të qëndruar gjithmonë i lidhur. Trafiku i rrjetit do të lejohet vetëm kur të lidhet me këtë VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Asnjë"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"VPN-ja gjithnjë e aktivizuar kërkon një adresë IP-je për serverin dhe DNS-në."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Nuk ka lidhje rrjeti. Provo sërish më vonë."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Mungon një certifikatë. Redakto profilin."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistemi"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Përdoruesi"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Çaktivizo"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Aktivizo"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Hiq"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Beso"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Të aktivizohet certifikata CA e sistemit?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Të çaktivizohet certifikata CA e sistemit?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Të hiqet përgjithmonë certifikata CA e përdoruesit?"</string>
    <string name="one_userkey" msgid="6034020579534914349">"çelës për një përdorues"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"certifikatë për një përdorues"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"një certifikatë CA"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"%d certifikata CA"</string>
    <string name="user_credential_title" msgid="1329449215749665378">"Detajet e kredencialeve"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Kontrolluesi drejtshkrimor"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Shkruaj fjalëkalimin aktual për rezervimin e plotë"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Shkruaj fjalëkalimin e ri për rezervimin e plotë"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Rishkruaj fjalëkalimin e ri për rezervimin e plotë"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Vendos fjalëkalimin"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Anulo"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Përditësime të sistemit"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Çaktivizuar"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Tolerant"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Po zbaton"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Rrjeti mund të jetë i monitoruar"</string>
    <string name="done_button" msgid="1991471253042622230">"U krye!"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="other">Besoji ose hiqi certifikatat</item>
      <item quantity="one">Besoje ose hiqe certifikatën</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="1489335297837656666">
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> ka instaluar autoritete certifikatash në pajisjen tënde, të cilat mund ta lejojë atë të monitorojë aktivitetin e rrjetit të pajisjes, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit..\n\nPër më shumë informacione rreth këtyre certifikatave, kontakto me administratorin.</item>
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> ka instaluar një autoritet certifikate në pajisjen tënde, i cili mund ta lejojë atë të monitorojë aktivitetin e rrjetit të pajisjes, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth kësaj certifikate, kontakto me administratorin.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="30645643499556573">
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> ka instaluar autoritete certifikate për profilin tënd të punës që mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të punës, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth këtyre certifikatave, kontakto me administratorin.</item>
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> ka instaluar një autoritet certifikate për profilin tënd të punës që mund ta lejojë atë të monitorojë aktivitetin tënd të rrjetit të punës, duke përfshirë mail-et, aplikacionet dhe sajtet e sigurta të uebit.\n\nPër më shumë informacione rreth kësaj certifikate, kontakto me administratorin.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Një palë e tretë është në gjendje të monitorojë aktivitetin e rrjetit, përfshirë mail-in, aplikacionet dhe faqet e sigurta të internetit.\n\nKëtë po e bën këtë të mundur një kredencial i besuar i instaluar në pajisjen tënde."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="other">Kontrollo certifikatat</item>
      <item quantity="one">Kontrollo certifikatën</item>
    </plurals>
    <string name="user_settings_title" msgid="6151874007858148344">"Përdoruesit"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Përdoruesit dhe profilet"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Shto një përdorues ose një profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Shto përdorues"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Profil i kufizuar"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"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="8311219392856626841">"Cakto kyçjen"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nuk është konfiguruar"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"E pakonfiguruar - Profil i kufizuar"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Nuk është konfiguruar - profili i punës"</string>
    <string name="user_admin" msgid="993402590002400782">"Administrator"</string>
    <string name="user_you" msgid="1639158809315025986">"Ti (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Pseudonimi"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Shto"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Mund të shtosh deri në <xliff:g id="USER_COUNT">%1$d</xliff:g> përdorues"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Përdoruesit kanë aplikacionet dhe përmbajtjet e tyre"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Mund të kufizosh qasjen në aplikacione dhe përmbajtje nga llogaria jote"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Përdoruesi"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Profil i kufizuar"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Të shtohet përdoruesi i ri?"</string>
    <string name="user_add_user_message_long" msgid="8562152293752222985">"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ë."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"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="1765794166801864563">"Të konfig. përdoruesi tani?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"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="3896568553327558731">"Të konfigurohet tani profili?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Konfiguro tani"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Jo tani"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Vetëm zotëruesi i tabletit mund t\'i menaxhojë përdoruesit."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Vetëm zotëruesi i telefonit mund t\'i menaxhojë përdoruesit."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Profilet e kufizuar nuk mund të shtojnë llogari"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Fshije <xliff:g id="USER_NAME">%1$s</xliff:g> nga pajisja"</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Cilësimet e ekranit të kyçjes"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2250956835192699766">"Shto përdorues"</string>
    <string name="user_add_on_lockscreen_menu_summary" msgid="133203601188164761">"kur pajisja është e kyçur"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Përdorues i ri"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Profili i ri"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Do e fshish veten?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Të fshihet ky përdorues?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Të hiqet ky profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Të hiqet profili i punës?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Do të humbësh hapësirën tënde dhe të dhënat në këtë tablet. Nuk mund ta zhbësh këtë veprim."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Do të humbësh hapësirën tënde dhe të dhënat në këtë telefon. Nuk mund ta zhbësh këtë veprim!"</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Të gjitha aplikacionet dhe të dhënat do të fshihen."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Të gjitha aplikacionet dhe të dhënat në këtë profil do të fshihen nëse vazhdon."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Të gjitha aplikacionet dhe të dhënat do të fshihen."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Po shton përdorues të ri..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Fshi përdoruesin"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Fshi"</string>
    <string name="user_guest" msgid="8475274842845401871">"I ftuar"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Hiq të ftuarin"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Të hiqet i ftuari?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Të gjitha aplikacionet dhe të dhënat në këtë sesion do të fshihen."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Hiq!"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Aktivizo telefonatat"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Aktivizo telefonatat dhe SMS-të"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Hiqe përdoruesin"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Të aktivizohen telefonatat?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Historiku i telefonatave do të ndahet me këtë përdorues."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Të aktivizohen telefonatat dhe SMS-të?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"Historiku i telefonatave dhe SMS-ve do të ndahet me këtë përdorues."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Informacioni i urgjencës"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Lejo aplikacionet dhe përmbajtjen"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikacionet me kufizime"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Zgjeroji cilësimet për aplikacionin"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Çinstaloje këtë aplikacion"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Cilësimet e \"Faqes kryesore\" do të fshihen derisa të instalosh një tjetër aplikacion të faqes kryesore."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Ky cilësim ndikon te të gjithë përdoruesit në këtë tablet."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Ky cilësim ndikon te të gjithë përdoruesit në këtë telefon."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Ndrysho gjuhën"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Trokit dhe paguaj"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Si funksionon"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Paguaj me telefonin tënd në dyqane"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Aplikacioni i parazgjedhur për pagesat"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Nuk është caktuar"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> - <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Përdor opsionin e parazgjedhur"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Gjithmonë!"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Përveçse kur është i hapur një aplikacion tjetër pagese"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Në terminalin \"Prek dhe paguaj\", paguaj me:"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Pagesa në terminal"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"Konfiguro një aplikacion pagese. Më pas thjesht mbaj shtypur pjesën e pasme të telefonit me një terminal me simbolin e pagesave pa kontakt."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"E kuptova!"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Më shumë..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Të caktohet si preferencë?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Të përdoret gjithmonë <xliff:g id="APP">%1$s</xliff:g> për \"Prek dhe paguaj\"?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Të përdoret gjithmonë <xliff:g id="APP_0">%1$s</xliff:g> në vend të <xliff:g id="APP_1">%2$s</xliff:g> për \"Prek dhe paguaj\"?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Kufizimet"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Hiq kufizimet"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Ndrysho kodin PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Shfaq njoftimet"</string>
    <string name="help_label" msgid="6886837949306318591">"Ndihmë dhe komente"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Llogaria për përmbajtjen"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID-ja e fotos"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Kërcënimet ekstreme"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Merr sinjalizime për kërcënime ekstreme mbi jetën dhe pronën"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Kërcënime serioze"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Merr alarme për kërcënime serioze kundër jetës dhe pronës"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Sinjalizimet AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Merr buletine rreth rrëmbimeve të fëmijëve"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Përsërit"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Aktivizo \"Menaxherin e telefonatave\""</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Lejo këtë shërbim të menaxhojë si kryhen telefonatat."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Menaxheri i telefonatave"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2451014351355183338">"Transmetimet e emergjencës"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Operatorët e rrjetit"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Emrat e pikës së qasjes"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Modaliteti i përparuar 4G LTE"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Përdor të dhëna LTE për të përmirësuar zërin dhe komunikimet (Rekomandohet)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Lloji i preferuar i rrjetit"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (rekomandohet)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Karta SIM e punës"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Qasja tek aplikacioni e përmbajtja"</string>
    <string name="user_rename" msgid="8523499513614655279">"Riemërto"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Cakto kufizimet e aplikacionit"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Kontrollohet nga <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ky aplikacion mund të ketë qasje në llogaritë e tua"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Ky aplikacion mund të qaset te llogaritë e tua. Kontrollohet nga <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi‑Fi dhe rrjeti celular"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Lejo modifikimin e cilësimeve Wi-Fi dhe atyre celulare"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth-i"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Lejo modifikimin e çiftimeve të \"Bluetooth-it\" dhe cilësimet"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Lejo shkëmbimin e të dhënave kur pajisja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> prek një tjetër pajisje NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Lejo shkëmbimin e të dhënave kur tableti prek një tjetër pajisje"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Lejo shkëmbimin e të dhënave kur telefoni prek një tjetër pajisje"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Vendndodhja"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Lejo aplikacionet të përdorin informacionin e vendndodhjes tënde"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Prapa"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Përpara"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Përfundo"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Bëj një fotografi"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Zgjidh një fotografi nga \"Galeria\""</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Zgjidh një fotografi"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"Kartat SIM"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"Kartat SIM"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> - <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Kartat SIM kanë ndryshuar"</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Trokit për të caktuar aktivitetet"</string>
    <string name="sim_cellular_data_unavailable" msgid="9018555543451203035">"Të dhënat celulare nuk ofrohen"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Trokit për të zgjedhur një kartë SIM për të dhëna"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Përdor gjithmonë këtë për telefonatat"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Përzgjidh një kartë SIM për të dhënat"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Po ndërron SIM-in e të dhënave. Kjo mund të zgjasë deri në një minutë..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Telefono me"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Zgjidh një kartë SIM"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"Karta SIM është bosh"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Emri i kartës SIM"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Fut emrin e kartës SIM"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Foleja e kartës SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operatori celular"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Numri"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Ngjyra e kartës SIM"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Zgjidh kartën SIM"</string>
    <string name="color_orange" msgid="4417567658855022517">"portokalli"</string>
    <string name="color_purple" msgid="3888532466427762504">"Vjollcë"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Nuk janë futur karta SIM"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Statusi i kartës SIM"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Telefono mbrapsht nga karta SIM e parazgjedhur"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"Karta SIM për telefonatat dalëse"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Cilësime të tjera të telefonatës"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Shkarkimi në rrjetin e preferuar"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Çaktivizo transmetimin e emrit të rrjetit"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Çaktivizimi i \"Transferimit të emrit të rrjetit\" mbron që të tjerë të mos qasen në informacionin e rrjetit."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Çaktivizimi i transmetimit të emrit të rrjetit do të parandalojë lidhjen automatike me rrjetet e fshehura."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6272913297433198340">"Kartat SIM kanë ndryshuar."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Trokit për ta konfiguruar"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Karta SIM e preferuar për"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Pyet çdo herë"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Kërkohet përzgjedhja"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Cilësimet"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Cilësimet"</string>
    <string name="search_menu" msgid="6283419262313758339">"Cilësimet e kërkimit"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Cilësimet e kërkimit"</string>
    <string name="search_recents_queries_label" msgid="2128811638532309069">"Kërkimet e fundit"</string>
    <string name="search_results_label" msgid="4163304782363526148">"Rezultatet"</string>
    <string name="keywords_wifi" msgid="1395786161993828719">"wifi, wi-fi, lidhje rrjeti"</string>
    <string name="keywords_more_default_sms_app" msgid="2265154063220360784">"mesazhe me tekst, dërgimi i mesazheve, mesazhe, mesazhim"</string>
    <string name="keywords_more_mobile_networks" msgid="1538131503712402851">"celular, operator celular, me valë, të dhëna, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, telefonatë, telefono"</string>
    <string name="keywords_home" msgid="3626170808219458848">"Nisësi"</string>
    <string name="keywords_display" msgid="8910345814565493016">"ekran, ekran me prekje"</string>
    <string name="keywords_display_brightness_level" msgid="3891383826236015854">"zbeh ekranin, ekran me prekje, bateri"</string>
    <string name="keywords_display_auto_brightness" msgid="3325150824507953765">"zbeh ekranin, ekran me prekje, bateri"</string>
    <string name="keywords_display_night_display" msgid="7630169927425425754">"errëso ekranin, natë, ngjyrosje"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"sfondi, personalizo, personalizo ekranin"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"madhësia e tekstit"</string>
    <string name="keywords_display_cast_screen" msgid="7684618996741933067">"projektoj, transmetoj"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"hapësirë, disk, njësi disku e ngurtë, përdorimi i pajisjes"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"përdorimi i energjisë, ngarkim"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"gërmëzim, fjalor, kontroll ortografik, korrigjim automatik"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"njohës, hyrje, fjalim, fol, gjuhë, pa duar, dorë, falas, njohje, ofenduese, fjalë, audio, historik, aparat, bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="5150660047085754699">"vlerëso, gjuhë e parazgjedhur, fol, duke folur, tts, qasje, lexues ekrani, i verbër"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"ora, ushtarake"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"rivendos, restauro, gjendje fabrike"</string>
    <string name="keywords_factory_data_reset" msgid="5894970373671252165">"spastro, fshi, restauro, pastro, hiq"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"printeri"</string>
    <string name="keywords_sounds" msgid="7146245090127541167">"sinjali bip i altoparlantit"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"mos, mos shqetëso, ndërprit, ndërprerje, pushim"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="6615286961552714686">"në afërsi, vendndodhje, historik, raportim"</string>
    <string name="keywords_location_mode" msgid="8584992704568356084">"saktësia"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"llogaria"</string>
    <string name="keywords_users" msgid="3434190133131387942">"kufizimi, kufizo, të kufizuara"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"korrigjim teksti, saktë, zë, dridhje, automatike, gjuhë, gjest, sugjero, sugjerim, temë, ofenduese, fjalë, emoji. ndërkombëtare"</string>
    <string name="keywords_reset_apps" msgid="5293291209613191845">"rivendos, preferencat, e parazgjedhur"</string>
    <string name="keywords_emergency_app" msgid="3143078441279044780">"urgjencë, akull, aplikacion, i parazgjedhur"</string>
    <string name="keywords_default_phone_app" msgid="4213090563141778486">"telefon, formuesi i numrave, i parazgjedhur"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"apl, shkarkim, aplikacione, sistem"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"aplikacione, leje, siguria"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"aplikacionet, e parazgjedhura"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"shpërfill optimizimet, sasia, aplikacioni në modalitet gatishmërie"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"ngjyrë e gjallë, RGB, sRGB, ngjyrë, natyrale, standarde"</string>
    <string name="keywords_color_temperature" msgid="2688947724153266364">"temperaturë e ftohtë D65 D73 e bardhë e verdhë blu e ngrohtë e ftohtë"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"rrëshqit për ta shkyçur, fjalëkalim, motiv, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"sfidë në punë, punë, profil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"profili i punës, profili i menaxhuar, unifiko, unifikim, punë, profil"</string>
    <string name="keywords_gesture" msgid="5696040361482126337">"gjesti"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Cakto një etiketë NFC për Wi-Fi"</string>
    <string name="write_tag" msgid="8571858602896222537">"Shkruaj"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Trokit te një etiketë për të shkruar..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Fjalëkalim i pavlefshëm. Provo sërish."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Me sukses!"</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Të dhënat nuk mund të shkruhen tek etiketa NFC. Nëse problemi vazhdon, provo një etiketë tjetër"</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"Etiketa NFC nuk mund të shkruhet. Përdor një etiketë tjetër."</string>
    <string name="default_sound" msgid="8821684447333687810">"Zëri i parazgjedhur"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Volumi i ziles në <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Volumi i ziles në 80%"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"volumi i klipit \"media\""</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Volumi i alarmit"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Volumi i ziles"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Volumi i njoftimit"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Zilja e telefonit"</string>
    <string name="notification_ringtone_title" msgid="3361201340352664272">"Zilja e parazgjedhur e njoftimit"</string>
    <string name="alarm_ringtone_title" msgid="2015124067611102995">"Zilja e parazgjedhur e alarmit"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Edhe dridhje për telefonatat"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Tinguj të tjerë"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonet e bllokut të tasteve"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Tingujt e kyçjes së ekranit"</string>
    <string name="charging_sounds_title" msgid="1132272552057504251">"Tingujt gjatë ngarkimit"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Tingujt e stacionimit"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Tingujt e prekjes"</string>
    <string name="vibrate_on_touch_title" msgid="5388579924689395023">"Dridhje pas trokitjes"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Luhet nga altoparlanti i stacionit"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Të gjitha audiot"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Vetëm klipe \"media\" audio"</string>
    <string name="emergency_tone_silent" msgid="1067515631635824291">"Në heshtje"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Sinjalizimi"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Dridhje"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Aktivizo tingujt"</string>
    <string name="zen_mode_settings_title" msgid="2689740350895257590">"Mos shqetëso"</string>
    <string name="zen_mode_priority_settings_title" msgid="2623117023031824309">"Vetëm njoftimet me prioritet"</string>
    <string name="zen_mode_automation_settings_title" msgid="4228995740594063774">"Rregullat automatike"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="3373871113435938830">"Cakto planifikimin për \"Mos shqetëso\""</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="8554080399360506596">"Vendose pajisjen në heshtje në kohë të caktuara"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Vetëm njoftimet me prioritet"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Vetëm alarmet"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Heshtje e plotë"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Blloko shqetësimet vizuale"</string>
    <string name="configure_notification_settings" msgid="3558846607192693233">"Konfiguro njoftimet"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Të përparuara"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Njoftimet e punës"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Pulso dritën e njoftimeve"</string>
    <string name="lock_screen_notifications_title" msgid="6173076173408887213">"Në ekranin e kyçjes"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Shfaq të gjithë përmbajtjen e njoftimit"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Fshih përmbajtjet delikate të njoftimeve"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Mos shfaq asnjë njoftim"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Kur pajisja jote të jetë e kyçur, si dëshiron të të shfaqen njoftimet?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1416589393106326972">"Njoftimet"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Shfaq të gjitha përmbajtjet e njoftimeve të punës"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="256116258285695645">"Fshih përmbajtjet delikate të njoftimeve të punës"</string>
    <string name="lock_screen_notifications_summary_disable_profile" msgid="4080720698960233358">"Mos shfaq asnjë njoftim pune"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Kur pajisja jote të jetë e kyçur, si dëshiron të shfaqen njoftimet e profilit?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Njoftimet e profilit"</string>
    <string name="app_notifications_title" msgid="139788604658984593">"Njoftimet"</string>
    <string name="notification_importance_title" msgid="848692592679312666">"Rëndësia"</string>
    <string name="notification_importance_none" msgid="3173515479356106227">"Nuk është caktuar"</string>
    <string name="notification_importance_blocked" msgid="4348392266695847526">"Mos trego asnjëherë njoftime nga ky aplikacion"</string>
    <string name="notification_importance_min" msgid="1859001310034196751">"Nuk ka ndërprerje të plotë të ekranit, shfaqje të shpejtë, tingull apo dridhje. Shfaqi në fund të listës së njoftimeve. Fshihe nga ekrani i kyçjes dhe shiriti i statusit."</string>
    <string name="notification_importance_low" msgid="1466326143251705794">"Nuk ka ndërprerje të plotë të ekranit, shfaqje të shpejtë, tingull apo dridhje."</string>
    <string name="notification_importance_default" msgid="2857618184137114962">"Nuk ka ndërprerje të plotë të ekranit apo shfaqje të shpejtë."</string>
    <string name="notification_importance_high" msgid="495354850199578732">"Gjithmonë shfaq shpejt. Nuk ka ndërprerje të plotë të ekranit."</string>
    <string name="notification_importance_max" msgid="7538045535631915413">"Gjithmonë shfaq shpejt dhe lejo ndërprerjen e ekranit të plotë. Shfaqe në krye të listës së njoftimeve."</string>
    <string name="notification_importance_unspecified" msgid="6172151762388245221">"Aplikacioni përcakton rëndësinë për çdo njoftim"</string>
    <string name="importance_reset" msgid="7458420788555607007">"Rivendos"</string>
    <string name="show_silently" msgid="2222875799232222056">"Shfaq në heshtje"</string>
    <string name="show_silently_summary" msgid="7616604629123146565">"Mos lësho tingull, dridhje apo t\'i shfaqësh me shpejtësi në pamje këto njoftime në ekranin aktual."</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Qasja te njoftimet"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikacionet nuk mund t\'i lexojnë njoftimet"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="other"> aplikacione mund të lexojnë njoftime</item>
      <item quantity="one">%d aplikacion mund të lexojë njoftime</item>
    </plurals>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Asnjë apl. i instaluar nuk ka kërkuar qasje te njoftimet."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Të lejohet qasja te njoftimet për <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> do të jetë në gjendje të lexojë të gjitha njoftimet, duke përfshirë informacione personale të tilla si emrat e kontakteve dhe tekstin e mesazheve që merr. Ai do të jetë po ashtu në gjendje t\'i heqë njoftimet ose të aktivizojë butonat e veprimeve që përmbajnë.\n\nKjo do t\'i japë aplikacionit aftësinë për të aktivizuar ose çaktivizuar \"Mos shqetëso\" dhe për të ndryshuar cilësimet përkatëse."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"Nëse çaktivizon qasjen e njoftimeve për <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, mund të çaktivizohet edhe qasja e \"Mos shqetëso\"."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="8333442186428083057">"Çaktivizo"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Anulo"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Shërbimet e ndihmësit VR"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Asnjë aplikacion i instaluar nuk ka kërkuar të ekzekutohet si shërbim ndihmësi VR."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Të lejohet qasja e shërbimit VR për <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> do të jetë në gjendje të ekzekutohet kur përdoren aplikacionet në modalitetin virtual."</string>
    <string name="display_vr_pref_title" msgid="7049857952347953979">"Kur pajisja është në modalitetin VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="6221441245293606681">"Përdor cilësimet e turbullimit të lëvizjes të ngadaltë"</string>
    <string name="display_vr_pref_off" msgid="1244880066079174840">"Mos bëj asgjë"</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Qasja te \"Mos shqetëso\""</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Asnjë aplikacion i instaluar nuk ka kërkuar qasje te \"Mos shqetëso\""</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Po ngarkon aplikacionet..."</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Bllokoji të gjitha"</string>
    <string name="app_notification_block_summary" msgid="9049487483231233726">"Mos shfaq asnjëherë njoftime nga ky aplikacion"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Anulo \"Mos shqetëso\""</string>
    <string name="app_notification_override_dnd_summary" msgid="3516007157020189746">"Lejo që këto njoftime të vazhdojnë të ndërpresin kur \"Mos shqetëso\" është vendosur në \"Vetëm prioritare\""</string>
    <string name="app_notification_visibility_override_title" msgid="2187232730902430718">"Në ekranin e kyçjes"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"I bllokuar"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Me prioritet"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Delikate"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"U krye!"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Rëndësia"</string>
    <string name="zen_mode_rule_name" msgid="5149068059383837549">"Emri i rregullit"</string>
    <string name="zen_mode_rule_name_hint" msgid="3781174510556433384">"Fut emrin e rregullit"</string>
    <string name="zen_mode_rule_name_warning" msgid="4517805381294494314">"Emri i rregullit është tashmë në përdorim"</string>
    <string name="zen_mode_add_rule" msgid="9100929184624317193">"Shto rregullin"</string>
    <string name="zen_mode_delete_rule" msgid="2985902330199039533">"Fshi rregullin"</string>
    <string name="zen_mode_choose_rule_type" msgid="5423746638871953459">"Zgjidh llojin e rregullit"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Të fshihet rregulli \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Fshi"</string>
    <string name="zen_mode_rule_type" msgid="2289413469580142888">"Lloji i rregullit"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"I panjohur"</string>
    <string name="zen_mode_configure_rule" msgid="8865785428056490305">"Konfiguro rregullin"</string>
    <string name="zen_schedule_rule_type_name" msgid="142936744435271449">"Rregulli i kohës"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Rregulli automatik u vendos. Ai do të aktivizojë gjendjen \"Mos shqetëso\" gjatë kohës së vendosur."</string>
    <string name="zen_event_rule_type_name" msgid="2645981990973086797">"Rregulli i ngjarjeve"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Rregulli automatik u vendos. Ai do të aktivizojë gjendjen \"Mos shqetëso\" gjatë kohës së vendosur."</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Gjatë ngjarjeve për"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Gjatë ngjarjeve për <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"çdo kalendar"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"Kur përgjigja është <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"Çdo kalendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"Kur përgjigja është"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"\"Po\", \"Ndoshta\" ose \"Jo\""</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"\"Po\" ose \"Ndoshta\""</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Po"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Rregulli nuk u gjet."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Aktive / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="3195058680641389948">"Ditët"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Asnjë"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Çdo ditë"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"Alarmi mund të anulojë kohën e mbarimit"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="4597050434723180422">"Ndalo në momentin e përfundimit ose kur të vijë alarmi tjetër, cilado prej tyre të ndodhë e para"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"<xliff:g id="START">%1$s</xliff:g> deri ditën <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="7051492091133751208">"Telefonatat"</string>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Mesazhet"</string>
    <string name="zen_mode_all_messages" msgid="6449223378976743208">"Të gjitha mesazhet"</string>
    <string name="zen_mode_selected_messages" msgid="8245990149599142281">"Mesazhet e përzgjedhura"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Nga të gjithë"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Vetëm nga kontaktet"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Vetëm nga kontaktet me yll"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Asnjë"</string>
    <string name="zen_mode_alarms" msgid="2165302777886552926">"Alarmet"</string>
    <string name="zen_mode_reminders" msgid="5458502056440485730">"Alarmet rikujtuese"</string>
    <string name="zen_mode_events" msgid="7914446030988618264">"Ngjarjet"</string>
    <string name="zen_mode_all_callers" msgid="584186167367236922">"Të gjithë telefonuesit"</string>
    <string name="zen_mode_selected_callers" msgid="3127598874060615742">"Telefonuesit e zgjedhur"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Telefonuesit e përsëritur"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="7192713032364140137">"Nëse telefonon i njëjti person për herë të dytë në një periudhë prej <xliff:g id="MINUTES">%d</xliff:g> minutash, lejoje"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Aktivizo automatikisht"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Asnjëherë!"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Çdo natë"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Natën gjatë javës"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Koha e nisjes"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Koha e përfundimit"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> ditën tjetër"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Ndrysho në gjendjen \"vetëm alarmet\" për një kohë të pacaktuar"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="other">Ndrysho në \"vetëm alarmet\" për <xliff:g id="DURATION">%1$d</xliff:g> minuta (deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Ndrysho në \"vetëm alarmet\" për një minutë deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="other">Kalo në \"vetëm alarme\" për <xliff:g id="DURATION">%1$d</xliff:g> orë deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="one">Kalo në \"vetëm alarme\" vetëm për një orë deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Ndrysho në gjendjen \"vetëm alarmet\" deri në <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Ndrysho te \"ndërprit gjithmonë\""</string>
    <string name="zen_mode_screen_on" msgid="7712038508173845101">"Blloko kur ekrani është aktiv"</string>
    <string name="zen_mode_screen_on_summary" msgid="6444425984146305149">"Mos lejo që njoftimet e vendosura në heshtje nga \"Mos shqetëso\" të duken apo të shfaqen në ekran"</string>
    <string name="zen_mode_screen_off" msgid="5026854939192419879">"Blloko kur ekrani është joaktiv"</string>
    <string name="zen_mode_screen_off_summary" msgid="6490932947651798094">"Mos lejo që njoftimet e vendosura në heshtje nga \"Mos shqetëso\" të aktivizojnë ekranin ose të bëjnë që drita e njoftimeve të pulsojë"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="3758698381956461866">"Parandalo aktivizimin e ekranit nga njoftimet e vendosura në heshtje nga \"Mos shqetëso\""</string>
    <string name="zen_mode_all_visual_interruptions" msgid="2851308980832487411">"Joaktiv"</string>
    <string name="zen_mode_screen_on_visual_interruptions" msgid="7373348148129140528">"Kur ekrani është aktiv"</string>
    <string name="zen_mode_screen_off_visual_interruptions" msgid="4850792880144382633">"Kur ekrani është joaktiv"</string>
    <string name="zen_mode_no_visual_interruptions" msgid="8742776003822778472">"Kur ekrani është aktiv ose joaktiv"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Cilësimet e njoftimeve"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Dërgo përshtypjet për këtë pajisje"</string>
    <string name="restr_pin_enter_admin_pin" msgid="2451187374960131018">"Fut kodin PIN të administratorit"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Aktivizuar"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Joaktiv"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Gozhdimi i ekranit"</string>
    <string name="screen_pinning_description" msgid="3360904523688769289">"Kur ky funksion është i aktivizuar, mund të përdorësh gozhdimin e ekranit për të mbajtur pamjen aktuale të ekranit deri sa ta anulosh gozhdimin.\n\nPër të përdorur gozhdimin e ekranit:\n\n1. Sigurohu që gozhdimi i ekranit është i aktivizuar.\n\n2. Hap ekranin që dëshiron të gozhdosh.\n\n3. Trokit te \"Përmbledhja\".\n\n4. Rrëshqit shpejt lart dhe më pas trokit tek ikona e gozhdimit."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Kërko motivin e shkyçjes para anulimit të mbërthimit"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Zhgozhdimi kërkon PIN-in"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Kërko fjalëkalim para heqjes nga gozhdimi"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Kyçe pajisjen kur heq gozhdimin"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Ky profil pune menaxhohet nga:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"I menaxhuar nga <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Eksperimentale)"</string>
    <string name="display_auto_rotate_title" msgid="6176450657107806043">"Kur pajisja rrotullohet"</string>
    <string name="display_auto_rotate_rotate" msgid="4544299861233497728">"Rrotullo përmbajtjen e ekranit"</string>
    <string name="display_auto_rotate_stay_in_portrait" msgid="292745182318093651">"Qëndro në pamjen vertikale"</string>
    <string name="display_auto_rotate_stay_in_landscape" msgid="3804752830204062162">"Qëndro në pamjen horizontale"</string>
    <string name="display_auto_rotate_stay_in_current" msgid="317932372686498096">"Qëndro në orientimin aktual"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informacioni i IMEI-t"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Nisje e sigurt"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Vazhdo"</string>
    <string name="encryption_interstitial_message_pin" msgid="7164072567822375682">"Mund ta mbrosh edhe më tepër këtë pajisje duke kërkuar kodin PIN para se të nisë. Deri sa pajisja të nisë, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarme.\n\nKjo ndihmon në mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura."</string>
    <string name="encryption_interstitial_message_pattern" msgid="6747091924626566031">"Mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar motivin para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet. \n\nKjo ndihmon në mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura."</string>
    <string name="encryption_interstitial_message_password" msgid="3462225324186045679">"Mund ta mbrosh edhe më tepër këtë pajisje duke kërkuar fjalëkalimin para se të niset. Derisa pajisja të niset, nuk mund të pranojë telefonata, mesazhe apo njoftime, përfshirë alarmet. \n\nKjo ndihmon në mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura."</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="3775537118799831558">"Përveç përdorimit të shenjave të gishtave për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar PIN para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon në mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura."</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="1105290967535237237">"Përveç përdorimit të shenjave të gishtave për të shkyçur pajisjen tënde, mund ta mbrosh edhe më shumë këtë pajisje duke kërkuar motivin para se të niset. Deri sa pajisja të niset, ajo nuk mund të marrë telefonata, mesazhe apo njoftime, duke përfshirë alarmet.\n\nKjo ndihmon në mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura."</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="3512482682507378424">"Përveç përdorimit të shenjave të gishtave për të shkyçur pajisjen tënde, mund ta mbrosh edhe më tepër këtë pajisje duke kërkuar fjalëkalimin para se të niset. Derisa pajisja të niset, nuk mund të pranojë telefonata, mesazhe apo njoftime, përfshirë alarmet.\n\nKjo ndihmon në mbrojtjen e të dhënave në pajisjet e humbura ose të vjedhura."</string>
    <string name="encrypt_require_pin" msgid="2063945047845243752">"Kërko kodin PIN për të nisur pajisjen"</string>
    <string name="encrypt_require_pattern" msgid="6898479411004015810">"Kërko motivin për të nisur pajisjen"</string>
    <string name="encrypt_require_password" msgid="8770628366276570518">"Kërko fjalëkalimin për të nisur pajisjen"</string>
    <string name="encrypt_dont_require_pin" msgid="1082444817726247368">"Jo, faleminderit"</string>
    <string name="encrypt_dont_require_pattern" msgid="6668299362640433843">"Jo, faleminderit"</string>
    <string name="encrypt_dont_require_password" msgid="2580403214917009046">"Jo, faleminderit"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Të kërkohet kodi PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Të kërkohet motivi?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Të kërkohet fjalëkalim?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Kur fut kodin PIN për të nisur këtë pajisje, nuk do të ofrohen ende shërbimet e qasshmërisë si <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Kur fut motivin për të nisur këtë pajisje, shërbimet e qasjes si <xliff:g id="SERVICE">%1$s</xliff:g> nuk do të jenë ende të gatshme."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Kur fut fjalëkalimin tënd për të nisur këtë pajisje, shërbimet si <xliff:g id="SERVICE">%1$s</xliff:g> nuk do të jenë ende të disponueshëm."</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="imei_information_title" msgid="8499085421609752290">"Informacioni i IMEI-t"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Informacioni përkatës i IMEI-t"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Foleja <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Hap me parazgjedhje"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="SIZE">%1$s</xliff:g> përdorur në <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Lidhjet po hapen"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Hap lidhjet e mbështetura"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Hape pa pyetur"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Lidhjet e mbështetura"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Parazgjedhjet e tjera"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="SIZE">%1$s</xliff:g> përdorur në <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="410824961149037234">"memoria e brendshme"</string>
    <string name="storage_type_external" msgid="8928374515368986503">"memoria e jashtme"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Hapësira e brendshme për ruajtje"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Hap. e jashtme ruajtëse"</string>
    <string name="app_data_usage" msgid="7942375313697452803">"Përdorimi i të dhënave të aplikacioneve"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"<xliff:g id="SIZE">%1$s</xliff:g> të përdorura që nga <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Hapësirë ruajtëse e përdorur"</string>
    <string name="change" msgid="6657848623929839991">"Ndrysho"</string>
    <string name="change_storage" msgid="600475265207060436">"Ndrysho hapësirën ruajtëse"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Njoftimet"</string>
    <string name="notifications_enabled" msgid="4386196629684749507">"Normale"</string>
    <string name="notifications_disabled" msgid="3200751656741989335">"Të bllokuara"</string>
    <string name="notifications_silenced" msgid="4728603513072110381">"Në heshtje"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Përmbajtja delikate jo në ekranin e kyçjes"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Jo në ekranin e kyçjes"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"\"Mos shqetëso\" u anulua"</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Niveli %d"</string>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> leje u dhanë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> leje u dha</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> nga <xliff:g id="COUNT_3">%d</xliff:g> leje të dhëna</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> nga <xliff:g id="COUNT_1">%d</xliff:g> leje e dhënë</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> leje shtesë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> leje shtesë</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Nuk është dhënë leje"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Nuk është kërkuar leje"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Të gjitha apl."</string>
    <string name="filter_enabled_apps" msgid="3318021007093070639">"Të aktivizuara"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Personale"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Punë"</string>
    <string name="filter_notif_blocked_apps" msgid="3446926933792244485">"Të bllokuara"</string>
    <string name="filter_with_domain_urls_apps" msgid="4573276638806792792">"Me URL-të e domenit"</string>
    <string name="filter_notif_priority_apps" msgid="5056470299318500609">"Anulon \"Mos shqetëso\""</string>
    <string name="filter_notif_sensitive_apps" msgid="3847012996691991486">"Nuk ka përmbajtje delikate në ekranin e kyçjes"</string>
    <string name="filter_notif_hide_notifications_apps" msgid="3977513041080404368">"Nuk shfaqet asnjëherë në ekranin e kyçjes"</string>
    <string name="filter_notif_silent" msgid="8533960664617048281">"Shfaqet në heshtje"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Të përparuara"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Konfiguro aplikacionet"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Aplikacion i panjohur"</string>
    <string name="app_permissions" msgid="4148222031991883874">"Lejet e aplikacionit"</string>
    <string name="app_permissions_summary" msgid="2098173899436407221">"<xliff:g id="COUNT_0">%d</xliff:g> nga gjithsej <xliff:g id="COUNT_1">%d</xliff:g> aplikacione lejuan qasje shtesë"</string>
    <string name="app_permissions_group_summary" msgid="2721303391744909000">"<xliff:g id="COUNT_0">%d</xliff:g> aplikacione nga <xliff:g id="COUNT_1">%d</xliff:g> të tilla u lejuan"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Trokit për ta zgjuar"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Trokit dy herë diku në ekran për ta zgjuar pajisjen."</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Lidhjet po hapen"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Mos i hap lidhjet e mbështetura"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Hap <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Hap <xliff:g id="DOMAIN">%s</xliff:g> dhe URL të tjera"</string>
    <plurals name="domain_urls_apps_summary" formatted="false" msgid="4322996467951692661">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacione mund t\'i hapin lidhjet e tyre të mbështetura</item>
      <item quantity="one">Një aplikacion mund t\'i hapë lidhjet e tij të mbështetura</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Hap në këtë aplikacion"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Pyet çdo herë"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Mos e hap në këtë aplikacion"</string>
    <string name="fingerprint_not_recognized" msgid="1739529686957438119">"Nuk njihet"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Të parazgjedhura"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Të parazgjedhura për punën"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Asistenti dhe hyrja zanore"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Aplikacioni i asistentit"</string>
    <string name="default_assist_none" msgid="3709083569608735487">"Asnjë"</string>
    <string name="choose_assist_title" msgid="2373353478479305516">"Zgjidh aplikacionin e asistentit"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Bëje <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> asistentin tënd?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"Asistenti do të jetë në gjendje të lexojë informacion rreth aplikacioneve në përdorim në sistemin tënd, duke përfshirë informacionin e dukshëm në ekran ose të qasshëm brenda aplikacioneve."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Pranoj"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Nuk pranoj"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Zgjidh hyrjen zanore"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Aplikacioni për shfletim"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Nuk ka asnjë shfletues të parazgjedhur"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Aplikacioni \"Telefoni\""</string>
    <string name="default_app" msgid="6864503001385843060">"(I parazgjedhur)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Sistemi)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Parazgjedhja e sistemit)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Hapësira ruajtëse e apl."</string>
    <string name="usage_access" msgid="5479504953931038165">"Qasja në përdorim"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Lejoje qasjen te përdorimi"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Preferencat e përdorimit të aplikacioneve"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"Qasja në përdorim lejon që një aplikacion të gjurmojë se çfarë përdorin aplikacionet e tjera dhe sa shpesh e përdorin, si edhe operatorin celular, cilësimet e gjuhës dhe detaje të tjera."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Memoria"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Detajet e memories"</string>
    <string name="always_running" msgid="6042448320077429656">"Gjithmonë në funksionim (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Përdoret ndonjëherë (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Përdoret rrallë (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maksimale"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Mesatare"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Maksimale <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Mesatarisht <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Optimizimi i baterisë"</string>
    <string name="high_power_filter_on" msgid="3222265297576680099">"Jo të optimizuara"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Nuk është i optimizuar"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Optimizojnë përdorimin e baterisë"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Optimizimi i baterisë nuk ofrohet"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"Mos zbato optimizimin e baterisë. Kjo mund ta shkarkojë baterinë më shpejt."</string>
    <plurals name="high_power_count" formatted="false" msgid="2464701722383894640">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacione u lejuan të shpërfillin optimizimin e baterisë</item>
      <item quantity="one">1 aplikacion u lejua të shpërfillë optimizimin e baterisë</item>
    </plurals>
    <string name="high_power_prompt_title" msgid="4257734526819699048">"Shpërfill optimizimet e baterisë?"</string>
    <string name="high_power_prompt_body" msgid="4072587909486730876">"Lejo që aplikacioni <xliff:g id="APP_NAME">%1$s</xliff:g> të qëndrojë i lidhur në sfond? Kjo mund të përdorë më shumë bateri."</string>
    <string name="battery_summary" msgid="101415762036784289">"<xliff:g id="PERCENTAGE">%1$d</xliff:g>%% përdorim që prej ngarkimit të fundit të plotë"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Asnjë përdorim i baterisë që prej ngarkimit të fundit të plotë"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Cilësimet e aplikacionit"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Shfaq sintonizuesin SystemUI"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Lejet shtesë"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"<xliff:g id="COUNT">%1$d</xliff:g> të tjera"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"Të ndahet raporti i defektit në kod?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"Administratori i teknologjisë së informacionit kërkoi një raport të defekteve në kod për të ndihmuar me zgjidhjen e problemeve. Aplikacioni dhe të dhënat mund të ndahen."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="3495929560689435496">"Administratori i teknologjisë së informacionit kërkoi një raport të defekteve në kod për të ndihmuar me zgjidhjen e problemeve. Aplikacioni dhe të dhënat mund të ndahen dhe kjo mund të ngadalësojë përkohësisht pajisjen tënde."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="5859287696666024466">"Ky raport i defektit në kod po ndahet me administratorin tënd të IT-së. Kontaktoje atë për më shumë detaje."</string>
    <string name="share_remote_bugreport_action" msgid="532226159318779397">"Shpërnda"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Refuzo"</string>
    <string name="usb_use_charging_only" msgid="2180443097365214467">"Karikuar këtë pajisje"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Vetëm karikoje këtë pajisje"</string>
    <string name="usb_use_power_only" msgid="6426550616883919530">"Furnizuar me energji elektrike"</string>
    <string name="usb_use_power_only_desc" msgid="4912352581010190141">"Furnizo me energji elektrike pajisjet e tjera të lidhura"</string>
    <string name="usb_use_file_transfers" msgid="7409600791007250137">"Transferuar skedarë"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Transfero skedarët te një pajisje tjetër"</string>
    <string name="usb_use_photo_transfers" msgid="7794775645350330454">"Transferuar fotografi (PTP)"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Transfero foto ose dosje, nëse MTP-ja nuk mbështetet (PTP)"</string>
    <string name="usb_use_MIDI" msgid="870922185938298263">"Përdorur pajisjen si MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Përdore këtë pajisje si MIDI"</string>
    <string name="usb_use" msgid="3256040963685055320">"Përdor USB-në për të"</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Kontrolli i sfondit"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Qasje e plotë në sfond"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Përdor tekstin nga ekrani"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Lejo që aplikacioni i asistentit të qaset te përmbajtjet e ekranit si tekst"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Përdor pamjen e ekranit"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Lejo që aplikacioni i asistentit të qaset te një imazh i ekranit"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Pulso ekranin"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Pulso këndet e ekranit kur aplikacioni ndihmës qaset në tekstin nga ekran apo pamja e ekranit"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Aplikacionet e asistentit të ndihmojnë bazuar në informacionet nga ekrani ku je duke e shikuar. Disa aplikacione mbështesin shërbimet e nisësit dhe të hyrjes me zë për të të siguruar një ndihmë të integruar."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Memoria mesatare në përdorim"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Përdorimi maksimal i memories"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Përdorimi i memories"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Përdorimi i aplikacionit"</string>
    <string name="memory_details" msgid="5943436005716991782">"Detajet"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Memoria mesatare e përdorur në 3 orët e fundit është <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"Nuk u përdor memoria në 3 orët e fundit"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Rendit sipas përdorimit mesatar"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Rendit sipas përdorimit maksimal"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Performanca"</string>
    <string name="total_memory" msgid="2017287600738630165">"Memoria totale"</string>
    <string name="average_used" msgid="5338339266517245782">"Mesatarja e përdorur (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"E lirë"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Memoria e përdorur nga aplikacionet"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacione përdorën memorien në <xliff:g id="DURATION_1">%2$s</xliff:g> e fundit</item>
      <item quantity="one">1 aplikacion përdori memorien në <xliff:g id="DURATION_0">%2$s</xliff:g> e fundit</item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Frekuenca"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Përdorimi maksimal"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Nuk janë përdorur të dhëna"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Të lejohet qasja te \"Mos shqetëso\" për <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Aplikacioni do të jetë në gjendje të aktivizojë/çaktivizojë opsionin \"Mos shqetëso\", si dhe të bëjë ndryshimet në cilësimet përkatëse."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"Duhet të qëndrojë e aktivizuar sepse qasja e njoftimeve është e aktivizuar"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="558779234015793950">"Të anulohet qasja te \"Mos shqetëso\" për <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="5518216907304930148">"Të gjitha rregullat e \"Mos shqetëso\" të krijuara nga ky aplikacion, do të hiqen."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Mos optimizo"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimizo"</string>
    <string name="ignore_optimizations_on_desc" msgid="2321398930330555815">"Mund ta shkarkojë baterinë më shpejt"</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Rekomandohet për një jetëgjatësi më të mirë të baterisë"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Lejo që <xliff:g id="APP">%s</xliff:g> t\'i injorojë optimizimet e baterisë?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Asnjë"</string>
    <string name="work_profile_usage_access_warning" msgid="8870622842216566692">"Çaktivizimi i qasjes së përdorimit për këtë aplikacion nuk e parandalon administratorin tënd të monitorojë përdorimin e të dhënave për aplikacionet në profilin tënd të punës."</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"<xliff:g id="COUNT_0">%1$d</xliff:g> nga <xliff:g id="COUNT_1">%2$d</xliff:g> karaktere u përdorën"</string>
    <string name="draw_overlay_title" msgid="4003905926278954971">"Aplikacione që mund të nxitin aplikacione të tjera"</string>
    <string name="draw_overlay" msgid="9078696044299199938">"Dalje mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_settings" msgid="1757821151143694951">"Dalje mbi aplikacionet e tjera"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplikacionet"</string>
    <string name="system_alert_window_access_title" msgid="8811695381437304132">"Nxit aplikacione të tjera"</string>
    <string name="permit_draw_overlay" msgid="6606018549732046201">"Lejo shfaqjen e funksionit mbi apl. e tjera"</string>
    <string name="app_overlay_permission_preference" msgid="8355410276571387439">"Leje që aplikacioni të dalë mbi të tjera"</string>
    <string name="allow_overlay_description" msgid="7895191337585827691">"Kjo leje lejon aplikacionin të dalë mbi aplikacionet e tjera që ti përdor dhe mund të ndërhyjë në përdorimin tënd të ndërfaqes në aplikacione të tjera, ose të ndryshojë atë që mendon se po sheh në aplikacionet e tjera."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"vr realitet virtual dëgjues stereo ndihmues shërbim"</string>
    <string name="keywords_system_alert_window" msgid="8579673659566564926">"sistem sinjalizim dritare dialog dil mbi aplikacionet e tjera"</string>
    <string name="overlay_settings" msgid="222062091489691363">"Nxit aplikacione të tjera"</string>
    <string name="system_alert_window_summary" msgid="4268867238063922290">"<xliff:g id="COUNT_0">%d</xliff:g> nga <xliff:g id="COUNT_1">%d</xliff:g> aplikacione të lejuar atë dalin mbi aplikacionet e tjera"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Aplikacionet me leje"</string>
    <string name="system_alert_window_on" msgid="2939489395109048888">"Po"</string>
    <string name="system_alert_window_off" msgid="6189115687233061992">"Jo"</string>
    <string name="write_settings" msgid="4797457275727195681">"Modifiko cilësimet e sistemit"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"shkruaj modifiko sistem cilësime"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"<xliff:g id="COUNT_0">%d</xliff:g> nga <xliff:g id="COUNT_1">%d</xliff:g> aplikacione lejohen të modifikojnë cilësimet e sistemit"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Mund të modifikojë cilësimet e sistemit"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Mund të modifikojë cilësimet e sistemit"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Modifiko cilësimet e sistemit"</string>
    <string name="write_settings_preference" msgid="3407383041273067448">"Leje për aplikacionin që të modifikojë cilësimet e sistemit"</string>
    <string name="permit_write_settings" msgid="6393779336656870080">"Lejo modifikimin e cilësimeve të sistemit"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Kjo leje e lejon një aplikacion të modifikojë cilësimet e sistemit."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Po"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Jo"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Rrotullo dy herë për kamerën"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Hap aplikacionin e kamerës duke rrotulluar kyçin e dorës dy herë"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"Shtyp butonin e energjisë dy herë për kamerën"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Hap me shpejtësi kamerën pa e shkyçur ekranin"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Madhësia e paraqitjes"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Bëji artikujt në ekran më të mëdhenj ose më të vegjël"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"dendësia e pamjes, zmadhimi i ekranit, shkalla, shkallëzimi"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Bëji artikujt në ekran më të vegjël ose më të mëdhenj. Disa aplikacione në ekran mund të ndryshojnë pozicionin."</string>
    <string name="screen_zoom_preview_title" msgid="4680671508172336572">"Pamja paraprake"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Zvogëlo"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Zmadho"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"Përshëndetje Ani!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Ej, do që të takohemi sot për një kafe?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Patjetër. Di unë një vend jo larg që këtu."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"Mrekulli!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"E martë 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"E martë 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"E martë 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"E martë 18:03"</string>
    <string name="see_all" msgid="8883901630052886984">"Shikoji të gjitha"</string>
    <string name="see_less" msgid="1250265310929558370">"Shiko më pak"</string>
    <string name="disconnected" msgid="5787956818111197212">"E shkëputur"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"<xliff:g id="AMOUNT">%1$s</xliff:g> nga të dhënat janë përdorur"</string>
    <plurals name="notification_summary" formatted="false" msgid="4019451362120557382">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacione u bllokuan për dërgimin</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aplikacion u bllokua për dërgimin</item>
    </plurals>
    <string name="notification_summary_none" msgid="3440195312233351409">"Të gjitha aplikaiconet lejohen të dërgojnë"</string>
    <string name="apps_summary" msgid="193158055537070092">"<xliff:g id="COUNT">%1$d</xliff:g> aplikacione të instaluara"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"24 aplikacione të instaluara"</string>
    <string name="storage_summary" msgid="1110250618334248745">"<xliff:g id="SIZE1">%1$s</xliff:g> nga <xliff:g id="SIZE2">%2$s</xliff:g> janë përdorur"</string>
    <string name="display_summary_on" msgid="5628868543070268634">"Ndriçimi përshtatës është AKTIV"</string>
    <string name="display_summary_off" msgid="6399558022426312990">"Ndriçimi përshtatës është JOAKTIV"</string>
    <string name="memory_summary" msgid="8080825904671961872">"Mesatarisht <xliff:g id="USED_MEMORY">%1$s</xliff:g> nga <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> memorie të përdorura"</string>
    <string name="user_summary" msgid="1617826998097722499">"Identifikuar si <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="3472482669588561110">"<xliff:g id="APP_NAME">%1$s</xliff:g> është i parazgjedhur"</string>
    <string name="location_on_summary" msgid="5127631544018313587">"AKTIV / <xliff:g id="LOCATION_MODE">%1$s</xliff:g>"</string>
    <string name="location_off_summary" msgid="6474350053215707957">"JOAKTIV"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Rezervimi u çaktivizua"</string>
    <string name="about_summary" msgid="8460677224778433924">"Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Veprimi nuk lejohet"</string>
    <string name="default_admin_support_msg" msgid="239311515653633217">"Ky veprim është çaktivizuar. Kontakto me administratorin e organizatës tënde për të mësuar më shumë."</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Më shumë detaje"</string>
    <string name="admin_profile_owner_message" msgid="5834937282929663252">"Administratori yt mund të monitorojë dhe menaxhojë aplikacionet dhe të dhënat që shoqërohen me profilin tënd të punës, duke përfshirë cilësimet, lejet, qasjen në korporatë, aktivitetin e rrjetit dhe informacionin e vendndodhjes së pajisjes tënde."</string>
    <string name="admin_profile_owner_user_message" msgid="7153676784012255048">"Administratori yt mund të monitorojë dhe menaxhojë aplikacionet dhe të dhënat që shoqërohen me këtë përdorues, duke përfshirë cilësimet, lejet, qasjen në korporatë, aktivitetin e rrjetit dhe informacionin e vendndodhjes së pajisjes tënde."</string>
    <string name="admin_device_owner_message" msgid="8734500370023898028">"Administratori yt mund të monitorojë dhe menaxhojë aplikacionet dhe të dhënat që shoqërohen me këtë pajisje, duke përfshirë cilësimet, lejet, qasjen në korporatë, aktivitetin e rrjetit dhe informacionin e vendndodhjes së pajisjes tënde."</string>
    <string name="condition_turn_off" msgid="1960945836880080298">"Çaktivizo"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Aktivizo"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Shfaq"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Fshih"</string>
    <string name="condition_hotspot_title" msgid="7778958849468560027">"Zona e qasjes për internet është aktive"</string>
    <string name="condition_hotspot_summary" msgid="3433182779269409683">"Zona portative e qasjes për internet Wi-Fi <xliff:g id="ID_1">%1$s</xliff:g> është aktive. Wi-Fi për këtë pajisje është çaktivizuar."</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Modaliteti i aeroplanit është aktiv"</string>
    <string name="condition_airplane_summary" msgid="2136872325308526329">"Wi-Fi, Bluetooth dhe rrjeti celular janë të çaktivizuara. Nuk mund të bësh telefonata apo të lidhesh me internetin."</string>
    <string name="condition_zen_title" msgid="2679168532600816392">"\"Mos shqetëso\" është aktiv (<xliff:g id="ID_1">%1$s</xliff:g>)"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Kursyesi i baterisë është i aktivizuar"</string>
    <string name="condition_battery_summary" msgid="4418839236027977450">"Performanca është e ulët. Janë çaktivizuar shërbimet e vendndodhjes dhe të dhënat e sfondit."</string>
    <string name="condition_cellular_title" msgid="2398754272044917264">"Të dhënat e celularit janë të çaktivizuara"</string>
    <string name="condition_cellular_summary" msgid="1818046558419658463">"Interneti është i disponueshëm vetëm përmes Wi-Fi"</string>
    <string name="condition_bg_data_title" msgid="2483860304802846542">"Kursyesi i të dhënave është aktiv"</string>
    <string name="condition_bg_data_summary" msgid="656957852895282228">"Të dhënat e sfondit janë të disponueshme vetëm përmes lidhjes Wi-Fi. Kjo mund të ndikojë te disa aplikacione ose shërbime kur lidhja Wi-Fi nuk është e disponueshme."</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Profili i punës është i çaktivizuar"</string>
    <string name="condition_work_summary" msgid="7543202177571590378">"Janë çaktivizuar aplikacionet, sinkronizimi në sfond dhe veçoritë e tjera që lidhen me profilin e punës."</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"\"Drita e natës\" është aktive"</string>
    <string name="condition_night_display_summary" msgid="6156601053674688864">"Ekrani është me nuancë të kuqe. Kjo mund të të ndihmojë të biesh në gjumë."</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Sugjerime"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestion_remove" msgid="904627293892092439">"Hiqe"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Temperatura e ftohtë e ngjyrës"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Përdor ngjyra të ftohta të ekranit"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Për të zbatuar ndryshimin e ngjyrës, çaktivizoje ekranin"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Përditësimet automatike të sistemit"</string>
    <string name="usage" msgid="2977875522080448986">"Përdorimi"</string>
    <string name="cellular_data_usage" msgid="2763710678354680712">"Përdorimi i të dhënave celulare"</string>
    <string name="wifi_data_usage" msgid="686754111095324306">"Përdorimi i të dhënave me Wi-Fi"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Përdorimi i të dhënave me eternet"</string>
    <string name="wifi" msgid="1081550856200013637">"Wi-Fi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Eterneti"</string>
    <string name="cell_data_template" msgid="3308709914705592281">"Të dhëna celulare <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="wifi_data_template" msgid="501654649753761778">"<xliff:g id="ID_1">%1$s</xliff:g> të dhëna me Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="5775729859383597507">"Të dhëna me eternet <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="cell_warning_only" msgid="763147658209027140">"Paralajmërimi i të dhënave <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="cell_warning_and_limit" msgid="2273413629267437470">"Paralajmërimi i të dhënave <xliff:g id="ID_1">%1$s</xliff:g> / Kufiri i të dhënave <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="billing_cycle" msgid="5169909190811133499">"Cikli i faturimit"</string>
    <string name="billing_cycle_summary" msgid="9009106526129293752">"Cikli muor fillon në datë <xliff:g id="ID_1">%1$s</xliff:g> të çdo muaji"</string>
    <string name="billing_cycle_fragment_summary" msgid="1940518156600077066">"Çdo muaj duke filluar nga <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Kufizimet e rrjetit"</string>
    <string name="operator_warning" msgid="1862988028996859195">"Llogaritja e të dhënave nga operatori mund të ndryshojë nga llogaritja e pajisjes"</string>
    <string name="data_used_template" msgid="3245919669966296505">"<xliff:g id="ID_1">%1$s</xliff:g> të përdorura"</string>
    <string name="data_warning" msgid="209133958008062117">"Paralajmërimi i të dhënave"</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Cakto kufirin e të dhënave"</string>
    <string name="data_limit" msgid="1885406964934590552">"Kufiri i të dhënave"</string>
    <string name="data_usage_template" msgid="392191945602400904">"<xliff:g id="ID_1">%1$s</xliff:g> të përdorura mes datave <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1029654422228677273">"Konfiguro"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Aplikacionet e tjera të përfshira në përdorim"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacione lejohen të përdorin të dhëna të pakufizuara kur \"Kursyesi i të dhënave\" është aktiv</item>
      <item quantity="one">1 aplikacion lejohet të përdorë të dhëna të pakufizuara kur \"Kursyesi i të dhënave\" është aktiv</item>
    </plurals>
    <string name="data_saver_title" msgid="398458827917495765">"Kursyesi i të dhënave"</string>
    <string name="unrestricted_data_saver" msgid="7019858887510062789">"Qasje e pakufizuar te të dhënat"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Të dhënat e sfondit janë të çaktivizuara"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Aktiv"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Joaktiv"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Përdorim i pakufizuar i të dhënave"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Lejo qasjen e pakufizuar të të dhënave kur \"Kursyesi i të dhënave\" është aktiv"</string>
    <string name="home_app" msgid="4066188520886810030">"Aplikacioni bazë"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Nuk ka faqe bazë të parazgjedhur"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Nisje e sigurt"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"Kërko motiv për të nisur pajisjen. Ndërsa është e fikur, kjo pajisje nuk mund të marrë telefonata, mesazhe, njoftime apo alarme."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Kërko kod PIN për të nisur pajisjen. Ndërsa është e fikur, kjo pajisje nuk mund të marrë telefonata, mesazhe, njoftime apo alarme."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Kërko fjalëkalim për të nisur pajisjen. Ndërsa është e fikur, kjo pajisje nuk mund të marrë telefonata, mesazhe, njoftime apo alarme."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Shto një gjurmë tjetër gishti"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Shkyçe me një gisht tjetër"</string>
    <string name="battery_saver_on_summary" msgid="9072203872401530722">"Ndezur / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="8309471955051162327">"Fikur / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="battery_saver_desc_turn_on_auto_never" msgid="6715896635178578813">"Asnjëherë mos e aktivizo automatikisht"</string>
    <string name="battery_saver_desc_turn_on_auto_pct" msgid="7472323223085636533">"Aktivizoje automatikisht kur ka %1$s bateri"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"Nuk po përdoret optimizimi i baterisë"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Nëse pajisja është e kyçur, parandalo shkrimin e përgjigjeve ose teksteve të tjera te njoftimet"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Kontrolluesi drejtshkrimor i parazgjedhur"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Zgjidh kontrolluesin drejtshkrimor"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"I pazgjedhur"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(asnjë)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">": "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"paketa"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"çelësi"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"grupi"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(përmbledhja)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"dukshmëria"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"versioni publik"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"përparësia"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"rëndësia"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"shpjegimi"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"synimi"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"fshi synimin"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"synimi i ekranit të plotë"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"veprimet"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"titulli"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"hyrjet në largësi"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"pamja e personalizuar"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"shtesë"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"madhësia e pakos"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"tingulli"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"dridhje"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"e parazgjedhur"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"asnjë"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Objekti i renditjes mungon."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"Objekti i renditjes nuk e përmban këtë çelës."</string>
    <string name="special_access" msgid="8275242424094109976">"Qasje e veçantë"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Të pastrohen vërtet të dhënat e përdoruesit dhe të konvertohen tek enkriptimi i skedarit?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Pastro dhe konverto"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Rivendos kufizimin e normës së ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Është rivendosur kufizimi i normës së ShortcutManager"</string>
    <string name="notification_suggestion_title" msgid="4506524937307816475">"Kontrollo njoftimet e ekranit të kyçjes"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Shfaq ose fshih përmbajtjet e njoftimeve"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Të gjitha"</string>
    <string name="page_tab_title_support" msgid="6330657582897417458">"Mbështetja"</string>
    <string name="developer_density_summary" msgid="1998244213021456519">"<xliff:g id="ID_1">%d</xliff:g> dp"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"Gjerësia më e vogël"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Asnjë aplikacion i instaluar nuk ka kërkuar qasje te mesazhet SMS premium"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"Mesazhet SMS premium mund të kushtojnë dhe do të rritin faturat e operatorit tënd celular. Nëse e aktivizon lejen për një aplikacion, do të mund të dërgosh mesazhe SMS premium me atë aplikacion."</string>
    <string name="premium_sms_access" msgid="4660047004791638305">"Qasja te mesazhet SMS premium"</string>
    <string name="bluetooth_disabled" msgid="1558295505487648234">"Çaktivizuar"</string>
    <string name="demo_mode" msgid="2655748420527206870">"Modaliteti i demonstrimit"</string>
    <string name="support_escalation_title" msgid="4111071371281023145">"Ne jemi këtu për të ndihmuar"</string>
    <string name="support_escalation_24_7_title" msgid="8118369197749832074">"Ne jemi këtu për ty 24 orë në ditë"</string>
    <string name="support_escalation_24_7_content_description" msgid="3772776213036994533">"Ne jemi këtu për ty 24 orë në ditë"</string>
    <string name="support_escalation_summary" msgid="8473084168776014405">"Ekipi ynë i mbështetjes është këtu për t\'iu përgjigjur çdo problemi"</string>
    <string name="support_escalation_24_7_summary" msgid="2802773279262547187">"Ekipi ynë i mbështetjes është i disponueshëm gjatë të gjithë ditës, çdo ditë"</string>
    <string name="support_escalation_closed_summary" msgid="2240967274380168303">"Kërko ndihmë ose kthehu sërish gjatë orarit lokal të mbështetjes (ora lokale):&lt;br&gt;&lt;b&gt;<xliff:g id="OPERATION_HOURS">%s</xliff:g>&lt;/b&gt;"</string>
    <string name="support_escalation_no_internet_summary" msgid="2526082812336597989">"Orari i mbështetjes me telefon (ora lokale)&lt;br&gt;&lt;b&gt;<xliff:g id="OPERATION_HOURS">%s</xliff:g>&lt;/b&gt;"</string>
    <string name="support_escalation_unavailable_summary" msgid="5208552975245211898">"Kërko ndihmë ose kërko te këshillat dhe marifetet"</string>
    <string name="support_country_list_title" msgid="823853371280534111">"Mbështetje për:"</string>
    <string name="support_country_format" msgid="4502523713489559595">"<xliff:g id="COUNTRY">%s</xliff:g> - <xliff:g id="LANGUAGE">%s</xliff:g>"</string>
    <string name="support_phone_international_format" msgid="2143528744844720829">"<xliff:g id="LANGUAGE">%s</xliff:g> (<xliff:g id="PHONE">%s</xliff:g>)"</string>
    <string name="support_international_phone_title" msgid="1308334014138718455">"Po udhëton jashtë vendit?"</string>
    <string name="support_international_phone_summary" msgid="208231793637026927">"Mund të aplikohen tarifa ndërkombëtare"</string>
    <string name="support_escalation_by_phone" msgid="4843223043487058711">"Telefoni"</string>
    <string name="support_escalation_by_chat" msgid="977019859110763749">"Biseda"</string>
    <string name="support_tips_and_tricks_title" msgid="4153466795695447828">"Eksploro këshillat dhe të fshehtat"</string>
    <string name="support_help_feedback_title" msgid="693440287222186718">"Kërko për ndihmë dhe dërgo komente"</string>
    <string name="support_sign_in_required_title" msgid="1367187789121480440">"Kontakto me ndihmën"</string>
    <string name="support_sign_in_button_text" msgid="3054769428620671241">"Identifikohu"</string>
    <string name="support_sign_in_required_help" msgid="5200654782405538114">"Nuk mund të identifikohesh?"</string>
    <string name="support_disclaimer_title" msgid="4825302018208770031">"Dërgo informacionet e sistemit"</string>
    <string name="support_disclaimer_content" msgid="6702447747744624871">"Për të të ndihmuar në trajtimin e shpejtë të problemit tënd, na nevojiten informacione të sistemit për diagnostikim."</string>
    <string name="support_disclaimer_do_not_show" msgid="3378367075323727539">"Mos e shfaq përsëri"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Cilësimet e profilit të punës"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Kërkimi i kontakteve"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Lejo kërkimet e kontakteve nga organizata jote për të identifikuar telefonuesit dhe kontaktet"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> orë</item>
      <item quantity="one">1 orë</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="4666832442068789413">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minuta</item>
      <item quantity="one">1 minutë</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="3876307354560025025">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekonda</item>
      <item quantity="one">1 sekondë</item>
    </plurals>
    <string name="support_estimated_wait_time" msgid="6523081420029378051">"Pritja ~<xliff:g id="ESTIMATE">%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="automatic_storage_manager_settings" msgid="7819434542155181607">"Menaxho hapësirën ruajtëse"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"Për të ndihmuar në lirimin e hapësirës ruajtëse, menaxheri i hapësirës ruajtëse i heq fotografitë dhe videot e rezervuara nga pajisja jote."</string>
    <string name="automatic_storage_manager_days_title" msgid="2017913896160914647">"Hiq fotografitë dhe videot"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Menaxheri i hapësirës ruajtëse"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automatike"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Manual"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Liro hapësirën tani"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Gjestet"</string>
    <string name="gesture_preference_summary" msgid="8627850388011956901">"Gjeste të shpejta për të kontrolluar telefonin"</string>
    <string name="double_tap_power_for_camera_title" msgid="2993443929413421363">"Kalo te kamera"</string>
    <string name="double_tap_power_for_camera_summary" msgid="6988157149749655988">"Për të hapur me shpejtësi kamerën, thjesht trokit dy herë te butoni i energjisë. Funksionon nga çdo ekran"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Rrotulloje kamerën"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="ambient_display_title" msgid="7369291941168001738">"Kontrolli i shpejtë i ekranit"</string>
    <string name="ambient_display_summary" msgid="3606386731704368561">"Për ta kontrolluar telefonin pa e zgjuar plotësisht, trokit dy herë ose merre në duar."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2750203868053669600">"Rrëshqit shpejt për njoftimet"</string>
    <string name="fingerprint_swipe_for_notifications_summary" msgid="5274050434459511239">"Për të kontrolluar njoftimet, rrëshqit poshtë në sensorin e gjurmës së gishtit në pjesën e pasme të telefonit."</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Aktiv"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Joaktiv"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"Ngarkuesi i sistemit është i shkyçur tashmë"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="415954951226204461">"Lidhu me internetin fillimisht"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="5884723935668892613">"Lidhu me internetin ose kontakto me operatorin celular"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Nuk ofrohet në pajisjet e kyçura për një operator celular"</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"<xliff:g id="SIZE">%1$s</xliff:g> në total të bëra të disponueshme\n\nEkzekutimi i fundit në datën <xliff:g id="DATE">%2$s</xliff:g>"</string>
</resources>
