<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, 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="byteShort" msgid="202579285008794431">"B"</string>
    <string name="kilobyteShort" msgid="2214285521564195803">"kB"</string>
    <string name="megabyteShort" msgid="6649361267635823443">"MB"</string>
    <string name="gigabyteShort" msgid="7515809460261287991">"GB"</string>
    <string name="terabyteShort" msgid="1822367128583886496">"terabajt"</string>
    <string name="petabyteShort" msgid="5651571254228534832">"petabajt"</string>
    <string name="fileSizeSuffix" msgid="4233671691980131257">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="3381766946944136678">"&lt;Pa titull&gt;"</string>
    <string name="emptyPhoneNumber" msgid="5812172618020360048">"(Nuk ka numër telefoni)"</string>
    <string name="unknownName" msgid="7078697621109055330">"E panjohur"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2190754495304236490">"Posta zanore"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2285034592902077488">"MSISDN1"</string>
    <string name="mmiError" msgid="2862759606579822246">"Problem në lidhje ose kod i pavlefshëm MMI-je."</string>
    <string name="mmiFdnError" msgid="3975490266767565852">"Veprimi është i kufizuar vetëm kundrejt numrave me telefonim të përzgjedhur"</string>
    <string name="mmiErrorWhileRoaming" msgid="1204173664713870114">"Cilësimet e transferimit të telefonatave nuk mund të ndryshohen nga telefoni yt kur je në roaming."</string>
    <string name="serviceEnabled" msgid="7549025003394765639">"Shërbimi u aktivizua."</string>
    <string name="serviceEnabledFor" msgid="1463104778656711613">"Shërbimi u aktivizua për:"</string>
    <string name="serviceDisabled" msgid="641878791205871379">"Shërbimi është çaktivizuar."</string>
    <string name="serviceRegistered" msgid="3856192211729577482">"Regjistrimi ishte i suksesshëm."</string>
    <string name="serviceErased" msgid="997354043770513494">"Fshirja ishte e suksesshme."</string>
    <string name="passwordIncorrect" msgid="917087532676155877">"Fjalëkalimi është i pasaktë."</string>
    <string name="mmiComplete" msgid="6341884570892520140">"MMI-ja përfundoi."</string>
    <string name="badPin" msgid="888372071306274355">"PIN-i i vjetër që shkrove nuk është i saktë."</string>
    <string name="badPuk" msgid="4232069163733147376">"PUK-u që shkrove nuk është i saktë."</string>
    <string name="mismatchPin" msgid="2929611853228707473">"PIN-et që shkrove nuk përputhen."</string>
    <string name="invalidPin" msgid="7542498253319440408">"Shkruaj një PIN nga 4 deri në 8 numra."</string>
    <string name="invalidPuk" msgid="8831151490931907083">"Shkruaj një PUK me 8 numra ose më të gjatë."</string>
    <string name="needPuk" msgid="7321876090152422918">"Karta jote SIM nuk është e kyçur me PUK. Shkruaj kodin PUK për ta shkyçur."</string>
    <string name="needPuk2" msgid="7032612093451537186">"Shkruaj kodin PUK2 për të shkyçur kartën SIM."</string>
    <string name="enablePin" msgid="2543771964137091212">"Pa sukses! Aktivizo kyçjen e SIM/RUIM."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1619867269012213584">
      <item quantity="other">Të kanë mbetur edhe <xliff:g id="NUMBER_1">%d</xliff:g> tentativa para se karta SIM të kyçet.</item>
      <item quantity="one">Të ka mbetur edhe <xliff:g id="NUMBER_0">%d</xliff:g> tentativë para se karta SIM të kyçet.</item>
    </plurals>
    <string name="imei" msgid="2157082351232630390">"IMEI"</string>
    <string name="meid" msgid="3291227361605924674">"MEID"</string>
    <string name="ClipMmi" msgid="4110549342447630629">"ID-ja e telefonuesit hyrës"</string>
    <string name="ClirMmi" msgid="4702929460236547156">"ID-ja e telefonuesit në dalje"</string>
    <string name="ColpMmi" msgid="4736462893284419302">"ID-ja e linjës së lidhur"</string>
    <string name="ColrMmi" msgid="5889782479745764278">"Kufizimi i ID-së së linjës së lidhur"</string>
    <string name="CfMmi" msgid="8390012691099787178">"Transferimi i telefonatave"</string>
    <string name="CwMmi" msgid="3164609577675404761">"Pritja e telefonatave"</string>
    <string name="BaMmi" msgid="7205614070543372167">"Bllokimi i telefonatave"</string>
    <string name="PwdMmi" msgid="3360991257288638281">"Ndryshimi i fjalëkalimit"</string>
    <string name="PinMmi" msgid="7133542099618330959">"Ndryshim PIN-i"</string>
    <string name="CnipMmi" msgid="4897531155968151160">"Numri i telefonatës është i pranishëm"</string>
    <string name="CnirMmi" msgid="885292039284503036">"Numri i telefonatës është i kufizuar"</string>
    <string name="ThreeWCMmi" msgid="2436550866139999411">"Telefonata me tre drejtime"</string>
    <string name="RuacMmi" msgid="1876047385848991110">"Refuzimi i telefonatave të padëshirueshme e të bezdisshme"</string>
    <string name="CndMmi" msgid="185136449405618437">"Dërgimi i numrit të telefonit"</string>
    <string name="DndMmi" msgid="8797375819689129800">"Mos shqetëso"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="4511621022859867988">"ID-ja e telefonuesit kalon me paracaktim në listën e të telefonuesve të kufizuar. Telefonata e radhës: E kufizuar!"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="5036749051007098105">"ID-ja e telefonuesit kalon me paracaktim në listën e të telefonuesve të kufizuar. Telefonata e radhës: e pakufizuar!"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="1022781126694885017">"ID-ja e telefonuesit kalon me paracaktim në listën e të telefonuesve të pakufizuar. Telefonata e radhës: e kufizuar!"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2491576172356463443">"ID-ja e telefonuesit kalon me paracaktim në listën e të telefonuesve të pakufizuar. Telefonata e radhës: e pakufizuar!"</string>
    <string name="serviceNotProvisioned" msgid="8289333510236766193">"Shërbimi nuk është përgatitur."</string>
    <string name="CLIRPermanent" msgid="166443681876381118">"Nuk mund ta ndryshosh cilësimin e ID-së së telefonuesit."</string>
    <string name="RestrictedOnDataTitle" msgid="1500576417268169774">"Nuk ka shërbim të të dhënave celulare"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="2852916906106191866">"Telefonatat e urgjencës nuk ofrohen"</string>
    <string name="RestrictedOnNormalTitle" msgid="7009474589746551737">"Nuk ka shërbim zanor"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="3982069078579103087">"Nuk ka shërbim zanore ose telefonata urgjence"</string>
    <string name="RestrictedStateContent" msgid="7693575344608618926">"Çaktivizuar përkohësisht nga operatori yt celular"</string>
    <string name="RestrictedStateContentMsimTemplate" msgid="5228235722511044687">"Çaktivizuar përkohësisht nga operatori yt celular për kartën SIM <xliff:g id="SIMNUMBER">%d</xliff:g>"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="1008329951315753038">"Rrjeti celular është i paarritshëm"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="2086506181486324860">"Provo të ndryshosh rrjetin e preferuar. Trokit për ta ndryshuar."</string>
    <string name="EmergencyCallWarningTitle" msgid="1615688002899152860">"Telefonatat e urgjencës nuk ofrohen"</string>
    <string name="EmergencyCallWarningSummary" msgid="1194185880092805497">"Nuk mund të kryhen telefonata urgjence me Wi‑Fi"</string>
    <string name="notification_channel_network_alert" msgid="4788053066033851841">"Sinjalizimet"</string>
    <string name="notification_channel_call_forward" msgid="8230490317314272406">"Transferimi i telefonatave"</string>
    <string name="notification_channel_emergency_callback" msgid="54074839059123159">"Modaliteti i \"Kthimit të telefonatës së urgjencës\""</string>
    <string name="notification_channel_mobile_data_status" msgid="1941911162076442474">"Statusi i të dhënave celulare"</string>
    <string name="notification_channel_sms" msgid="1243384981025535724">"Mesazhet SMS"</string>
    <string name="notification_channel_voice_mail" msgid="8457433203106654172">"Mesazhet e postës zanore"</string>
    <string name="notification_channel_wfc" msgid="9048240466765169038">"Telefonata me Wi-Fi"</string>
    <string name="notification_channel_sim" msgid="5098802350325677490">"Statusi i kartës SIM"</string>
    <string name="notification_channel_sim_high_prio" msgid="642361929452850928">"Statusi i kartës SIM me përparësi të lartë"</string>
    <string name="peerTtyModeFull" msgid="337553730440832160">"Homologu yt kërkoi modalitet \"TTY\" të plotë"</string>
    <string name="peerTtyModeHco" msgid="5626377160840915617">"Homologu kërkoi modalitet \"TTY\" të llojit \"HCO\""</string>
    <string name="peerTtyModeVco" msgid="572208600818270944">"Homologu yt kërkoi modalitet \"TTY\" të llojit \"VCO\""</string>
    <string name="peerTtyModeOff" msgid="2420380956369226583">"Homologu kërkoi modalitet \"TTY\" të çaktivizuar"</string>
    <string name="serviceClassVoice" msgid="2065556932043454987">"Zëri"</string>
    <string name="serviceClassData" msgid="4148080018967300248">"Të dhëna"</string>
    <string name="serviceClassFAX" msgid="2561653371698904118">"Faks"</string>
    <string name="serviceClassSMS" msgid="1547664561704509004">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="2029856900898545984">"jo-sinkronizim"</string>
    <string name="serviceClassDataSync" msgid="7895071363569133704">"Sinkronizo"</string>
    <string name="serviceClassPacket" msgid="1430642951399303804">"Paketë"</string>
    <string name="serviceClassPAD" msgid="6850244583416306321">"PAD"</string>
    <string name="roamingText0" msgid="7793257871609854208">"Treguesi i roaming-ut është aktivizuar"</string>
    <string name="roamingText1" msgid="5073028598334616445">"Treguesi i roaming-ut është çaktivizuar"</string>
    <string name="roamingText2" msgid="2834048284153110598">"Treguesi i roaming-ut po pulson"</string>
    <string name="roamingText3" msgid="831690234035748988">"Larg periferisë"</string>
    <string name="roamingText4" msgid="2171252529065590728">"Jashtë ndërtesës"</string>
    <string name="roamingText5" msgid="4294671587635796641">"Roaming - Sistemi i preferuar"</string>
    <string name="roamingText6" msgid="5536156746637992029">"Roaming - Sistemi i mundësuar"</string>
    <string name="roamingText7" msgid="1783303085512907706">"Roaming - \"Partner Aleance\""</string>
    <string name="roamingText8" msgid="7774800704373721973">"Roaming - \"Premium Partner\""</string>
    <string name="roamingText9" msgid="1933460020190244004">"Roaming - Funksionalitet i plotë shërbimi"</string>
    <string name="roamingText10" msgid="7434767033595769499">"Roaming - Funksionalitet i pjesshëm shërbimi"</string>
    <string name="roamingText11" msgid="5245687407203281407">"Lajmëruesi i roaming-ut është i aktivizuar"</string>
    <string name="roamingText12" msgid="673537506362152640">"Lajmëruesi i roaming-ut është i çaktivizuar"</string>
    <string name="roamingTextSearching" msgid="5323235489657753486">"Po kërkon për shërbim"</string>
    <string name="wfcRegErrorTitle" msgid="3193072971584858020">"Telefonata me Wi-Fi nuk mund të konfigurohej"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
    <item msgid="468830943567116703">"Për të bërë telefonata dhe për të dërguar mesazhe nëpërmjet Wi-Fi, në fillim kërkoji operatorit celular të konfigurojë këtë shërbim. Më pas aktivizo përsëri telefonatat me Wi-Fi nga \"Cilësimet\". (Kodi i gabimit: <xliff:g id="CODE">%1$s</xliff:g>)"</item>
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
    <item msgid="4795145070505729156">"Problem gjatë regjistrimit të telefonatave me Wi‑Fi me operatorin tënd celular: <xliff:g id="CODE">%1$s</xliff:g>"</item>
  </string-array>
    <!-- no translation found for wfcSpnFormat_spn (2982505428519096311) -->
    <skip />
    <string name="wfcSpnFormat_spn_wifi_calling" msgid="3165949348000906194">"Telefonatë me Wi-Fi në <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_wifi_calling_vo_hyphen" msgid="3836827895369365298">"Telefonatat me WiFi me <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wlan_call" msgid="4895315549916165700">"Telefonatë me WLAN"</string>
    <string name="wfcSpnFormat_spn_wlan_call" msgid="255919245825481510">"Telefonatë me WLAN në <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_wifi" msgid="7232899594327126970">"Wi-Fi në <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wifi_calling_bar_spn" msgid="8383917598312067365">"Telefonatë me Wi-Fi | <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_vowifi" msgid="6865214948822061486">"VoWifi në <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wifi_calling" msgid="6178935388378661755">"Telefonatë me Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi" msgid="1376356951297043426">"Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen" msgid="7178561009225028264">"Telefonatë me WiFi"</string>
    <string name="wfcSpnFormat_vowifi" msgid="8371335230890725606">"VoWifi"</string>
    <string name="wifi_calling_off_summary" msgid="5626710010766902560">"Çaktivizuar"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1035175836270943089">"Telefono nëpërmjet Wi-Fi"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="4958965609212575619">"Telefono nëpërmjet rrjetit celular"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="104951993894678665">"Vetëm Wi-Fi"</string>
    <string name="cfTemplateNotForwarded" msgid="862202427794270501">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nuk u transferua"</string>
    <string name="cfTemplateForwarded" msgid="9132506315842157860">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="735042369233323609">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> pas <xliff:g id="TIME_DELAY">{2}</xliff:g> sekondash"</string>
    <string name="cfTemplateRegistered" msgid="5619930473441550596">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nuk u transferua"</string>
    <string name="cfTemplateRegisteredTime" msgid="5222794399642525045">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nuk u transferua"</string>
    <string name="fcComplete" msgid="1080909484660507044">"Kodi i funksionit është i plotë."</string>
    <string name="fcError" msgid="5325116502080221346">"Problem me lidhjen ose kod është i pavlefshëm."</string>
    <string name="httpErrorOk" msgid="6206751415788256357">"Në rregull!"</string>
    <string name="httpError" msgid="3406003584150566720">"Pati një gabim në rrjet."</string>
    <string name="httpErrorLookup" msgid="3099834738227549349">"Nuk mundi ta gjente URL-në."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="3976195595501606787">"Skema e vërtetimit nuk mbështetet."</string>
    <string name="httpErrorAuth" msgid="469553140922938968">"Nuk mundi ta vërtetonte."</string>
    <string name="httpErrorProxyAuth" msgid="7229662162030113406">"Vërtetimi përmes serverit të autorizuar ishte i pasuksesshëm."</string>
    <string name="httpErrorConnect" msgid="3295081579893205617">"Nuk mundi të lidhej me serverin."</string>
    <string name="httpErrorIO" msgid="3860318696166314490">"Nuk mund të komunikohej me serverin. Provo sërish."</string>
    <string name="httpErrorTimeout" msgid="7446272815190334204">"Lidhjes me serverin i përfundoi koha."</string>
    <string name="httpErrorRedirectLoop" msgid="8455757777509512098">"Faqja përmban shumë ri-drejtime të serverit."</string>
    <string name="httpErrorUnsupportedScheme" msgid="2664108769858966374">"Protokolli nuk mbështetet."</string>
    <string name="httpErrorFailedSslHandshake" msgid="546319061228876290">"Nuk mund të vendosej një lidhje e sigurt."</string>
    <string name="httpErrorBadUrl" msgid="754447723314832538">"Nuk mundi ta hapte faqen sepse URL-ja është e pavlefshme."</string>
    <string name="httpErrorFile" msgid="3400658466057744084">"Nuk mundi të qasej te skedari."</string>
    <string name="httpErrorFileNotFound" msgid="5191433324871147386">"Nuk mundi ta gjente skedarin e kërkuar."</string>
    <string name="httpErrorTooManyRequests" msgid="2149677715552037198">"Po përpunohen shumë kërkesa. Provo sërish më vonë."</string>
    <string name="notification_title" msgid="5783748077084481121">"Gabim identifikimi për <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="2341041749565687871">"Sinkronizo"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="5766411446676388623">"Nuk mund të sinkronizohet"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="4562226280528716090">"U përpoqe të fshish shumë <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="5557552311566179924">"Hapësira ruajtëse e tabletit është plot. Fshi disa skedarë për të liruar hapësirë."</string>
    <string name="low_memory" product="watch" msgid="3479447988234030194">"Hapësira ruajtëse e orës është plot. Fshi disa skedarë për të liruar hapësirë."</string>
    <string name="low_memory" product="tv" msgid="8803524975509826759">"Hapësira ruajtëse e televizorit është plot. Fshi disa skedarë për të liruar hapësirë."</string>
    <string name="low_memory" product="default" msgid="2539532364144025569">"Hapësira ruajtëse e telefonit është plot. Fshi disa skedarë për të liruar hapësirë."</string>
    <plurals name="ssl_ca_cert_warning" formatted="false" msgid="2288194355006173029">
      <item quantity="other">Autoritetet e certifikatës janë instaluar</item>
      <item quantity="one">Autoriteti i certifikatës është instaluar</item>
    </plurals>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4961102218216815242">"Nga një palë e tretë e panjohur"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="4564941950768783879">"Nga administratori i profilit tënd të punës"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="217337232273211674">"Nga <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5891181538182009328">"Profili i punës u fshi"</string>
    <string name="work_profile_deleted_details" msgid="3773706828364418016">"Aplikacioni i administratorit të profilit të punës mungon ose është dëmtuar. Si rezultat i kësaj, profili yt i punës dhe të dhënat përkatëse janë fshirë. Kontakto me administratorin për ndihmë."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="2477244968924647232">"Profili yt i punës nuk është më i disponueshëm në këtë pajisje"</string>
    <string name="work_profile_deleted_reason_maximum_password_failure" msgid="1080323158315663167">"Shumë përpjekje për fjalëkalimin"</string>
    <string name="network_logging_notification_title" msgid="554983187553845004">"Pajisja është e menaxhuar"</string>
    <string name="network_logging_notification_text" msgid="1327373071132562512">"Organizata jote e menaxhon këtë pajisje dhe mund të monitorojë trafikun e rrjetit. Trokit për detaje."</string>
    <string name="factory_reset_warning" msgid="6858705527798047809">"Pajisja do të spastrohet"</string>
    <string name="factory_reset_message" msgid="2657049595153992213">"Aplikacioni i administratorit nuk mund të përdoret. Pajisja jote tani do të fshihet.\n\nNëse ke pyetje, kontakto me administratorin e organizatës."</string>
    <string name="printing_disabled_by" msgid="3517499806528864633">"Printimi është çaktivizuar nga <xliff:g id="OWNER_APP">%s</xliff:g>."</string>
    <string name="me" msgid="6207584824693813140">"Unë"</string>
    <string name="power_dialog" product="tablet" msgid="8333207765671417261">"Opsionet e tabletit"</string>
    <string name="power_dialog" product="tv" msgid="5941745051236770764">"Opsionet e televizorit"</string>
    <string name="power_dialog" product="default" msgid="1107775420270203046">"Opsionet e telefonit"</string>
    <string name="silent_mode" msgid="8796112363642579333">"Modaliteti \"në heshtje\""</string>
    <string name="turn_on_radio" msgid="2961717788170634233">"Aktivizo radion"</string>
    <string name="turn_off_radio" msgid="7222573978109933360">"Çaktivizo radion"</string>
    <string name="screen_lock" msgid="2072642720826409809">"Kyçja e ekranit"</string>
    <string name="power_off" msgid="4111692782492232778">"Fik"</string>
    <string name="silent_mode_silent" msgid="5079789070221150912">"Zilja është çaktivizuar"</string>
    <string name="silent_mode_vibrate" msgid="8821830448369552678">"Zile me dridhje"</string>
    <string name="silent_mode_ring" msgid="6039011004781526678">"Zilja u aktivizua"</string>
    <string name="reboot_to_update_title" msgid="2125818841916373708">"Përditësimi i sistemit Android"</string>
    <string name="reboot_to_update_prepare" msgid="6978842143587422365">"Po përgatitet për përditësimin…"</string>
    <string name="reboot_to_update_package" msgid="4644104795527534811">"Po përpunon paketën e përditësimit…"</string>
    <string name="reboot_to_update_reboot" msgid="4474726009984452312">"Po rinis…"</string>
    <string name="reboot_to_reset_title" msgid="2226229680017882787">"Rivendosja e të dhënave të fabrikës"</string>
    <string name="reboot_to_reset_message" msgid="3347690497972074356">"Po rinis…"</string>
    <string name="shutdown_progress" msgid="5017145516412657345">"Po fiket…"</string>
    <string name="shutdown_confirm" product="tablet" msgid="2872769463279602432">"Tableti yt do të fiket."</string>
    <string name="shutdown_confirm" product="tv" msgid="9187068694573722129">"Televizori yt do të fiket."</string>
    <string name="shutdown_confirm" product="watch" msgid="2977299851200240146">"Ora jote do të fiket."</string>
    <string name="shutdown_confirm" product="default" msgid="136816458966692315">"Telefoni yt do të fiket."</string>
    <string name="shutdown_confirm_question" msgid="796151167261608447">"Dëshiron ta fikësh?"</string>
    <string name="reboot_safemode_title" msgid="5853949122655346734">"Rifillo në \"modalitetin e sigurisë\""</string>
    <string name="reboot_safemode_confirm" msgid="1658357874737219624">"Dëshiron ta rinisësh në modalitetin e sigurt? Kjo do të çaktivizojë të gjitha aplikacionet e palëve të treta që ke instaluar. Ato do të rivendosen kur ta nisësh sërish."</string>
    <string name="recent_tasks_title" msgid="8183172372995396653">"Të fundit"</string>
    <string name="no_recent_tasks" msgid="9063946524312275906">"Nuk ka aplikacione të fundit."</string>
    <string name="global_actions" product="tablet" msgid="4412132498517933867">"Opsionet e tabletit"</string>
    <string name="global_actions" product="tv" msgid="2020669784083287370">"Opsionet e televizorit"</string>
    <string name="global_actions" product="default" msgid="6410072189971495460">"Opsionet e telefonit"</string>
    <string name="global_action_lock" msgid="6949357274257655383">"Kyçja e ekranit"</string>
    <string name="global_action_power_off" msgid="4404936470711393203">"Fik"</string>
    <string name="global_action_emergency" msgid="1387617624177105088">"Urgjenca"</string>
    <string name="global_action_bug_report" msgid="5127867163044170003">"Raporti i defekteve në kod"</string>
    <string name="global_action_logout" msgid="6093581310002476511">"Jepi fund sesionit"</string>
    <string name="global_action_screenshot" msgid="2610053466156478564">"Pamja e ekranit"</string>
    <string name="bugreport_title" msgid="8549990811777373050">"Raporti i defekteve në kod"</string>
    <string name="bugreport_message" msgid="5212529146119624326">"Ky funksion mundëson mbledhjen e informacioneve mbi gjendjen aktuale të pajisjes për ta dërguar si mesazh mail-i. Do të duhet pak kohë nga nisja e raportit të defekteve në kod. Faleminderit për durimin."</string>
    <string name="bugreport_option_interactive_title" msgid="7968287837902871289">"Raport interaktiv"</string>
    <string name="bugreport_option_interactive_summary" msgid="8493795476325339542">"Përdore këtë në shumicën e rrethanave. Të lejon të gjurmosh progresin e raportit dhe të fusësh më shumë detaje rreth problemit dhe të regjistrosh pamje të ekranit. Mund të fshijë disa seksione që përdoren më pak të cilat kërkojnë shumë kohë për t\'u raportuar."</string>
    <string name="bugreport_option_full_title" msgid="7681035745950045690">"Raporti i plotë"</string>
    <string name="bugreport_option_full_summary" msgid="1975130009258435885">"Përdore këtë opsion për interferencë minimale kur pajisja nuk përgjigjet ose është tepër e ngadaltë, ose kur të nevojiten të gjitha seksionet. Nuk të lejon që të fusësh më shumë të dhëna ose të regjistrosh pamje të të tjera ekrani."</string>
    <plurals name="bugreport_countdown" formatted="false" msgid="3906120379260059206">
      <item quantity="other">Marrja e pamjes së ekranit për raportin e defektit në kod në <xliff:g id="NUMBER_1">%d</xliff:g> sekonda.</item>
      <item quantity="one">Marrja e pamjes së ekranit për raportin e defektit në kod në <xliff:g id="NUMBER_0">%d</xliff:g> sekondë.</item>
    </plurals>
    <string name="global_action_toggle_silent_mode" msgid="8464352592860372188">"Modaliteti \"në heshtje\""</string>
    <string name="global_action_silent_mode_on_status" msgid="2371892537738632013">"Zëri është çaktivizuar"</string>
    <string name="global_action_silent_mode_off_status" msgid="6608006545950920042">"Zëri është i aktivizuar"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="6911684460146916206">"modaliteti i aeroplanit"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="5508025516695361936">"Modaliteti i aeroplanit është i AKTIVIZUAR"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="8522219771500505475">"Modaliteti i aeroplanit është i ÇAKTIVIZUAR"</string>
    <string name="global_action_settings" msgid="4671878836947494217">"Cilësimet"</string>
    <string name="global_action_assist" msgid="2517047220311505805">"Ndihma"</string>
    <string name="global_action_voice_assist" msgid="6655788068555086695">"Ndihma zanore"</string>
    <string name="global_action_lockdown" msgid="2475471405907902963">"Blloko"</string>
    <string name="status_bar_notification_info_overflow" msgid="3330152558746563475">"999+"</string>
    <string name="notification_hidden_text" msgid="2835519769868187223">"Njoftim i ri"</string>
    <string name="notification_channel_virtual_keyboard" msgid="6465975799223304567">"Tastiera virtuale"</string>
    <string name="notification_channel_physical_keyboard" msgid="5417306456125988096">"Tastiera fizike"</string>
    <string name="notification_channel_security" msgid="8516754650348238057">"Siguria"</string>
    <string name="notification_channel_car_mode" msgid="2123919247040988436">"Modaliteti \"në makinë\""</string>
    <string name="notification_channel_account" msgid="6436294521740148173">"Statusi i llogarisë"</string>
    <string name="notification_channel_developer" msgid="1691059964407549150">"Mesazhet e zhvilluesit"</string>
    <string name="notification_channel_updates" msgid="7907863984825495278">"Përditësimet"</string>
    <string name="notification_channel_network_status" msgid="2127687368725272809">"Statusi i rrjetit"</string>
    <string name="notification_channel_network_alerts" msgid="6312366315654526528">"Sinjalizimet e rrjetit"</string>
    <string name="notification_channel_network_available" msgid="6083697929214165169">"Ka rrjet të disponueshëm"</string>
    <string name="notification_channel_vpn" msgid="1628529026203808999">"Statusi i VPN-së"</string>
    <string name="notification_channel_device_admin" msgid="6384932669406095506">"Sinjalizimet nga administratori i teknologjisë së informacionit"</string>
    <string name="notification_channel_alerts" msgid="5070241039583668427">"Sinjalizimet"</string>
    <string name="notification_channel_retail_mode" msgid="3732239154256431213">"Demonstrimi i shitjes me pakicë"</string>
    <string name="notification_channel_usb" msgid="1528280969406244896">"Lidhja USB"</string>
    <string name="notification_channel_heavy_weight_app" msgid="17455756500828043">"Aplikacioni është në ekzekutim"</string>
    <string name="notification_channel_foreground_service" msgid="7102189948158885178">"Aplikacionet që konsumojnë baterinë"</string>
    <string name="foreground_service_app_in_background" msgid="1439289699671273555">"<xliff:g id="APP_NAME">%1$s</xliff:g> po përdor baterinë"</string>
    <string name="foreground_service_apps_in_background" msgid="7340037176412387863">"<xliff:g id="NUMBER">%1$d</xliff:g> aplikacione po përdorin baterinë"</string>
    <string name="foreground_service_tap_for_details" msgid="9078123626015586751">"Trokit për detaje mbi baterinë dhe përdorimin e të dhënave"</string>
    <string name="foreground_service_multiple_separator" msgid="5002287361849863168">"<xliff:g id="LEFT_SIDE">%1$s</xliff:g>, <xliff:g id="RIGHT_SIDE">%2$s</xliff:g>"</string>
    <string name="safeMode" msgid="8974401416068943888">"Modaliteti i sigurisë"</string>
    <string name="android_system_label" msgid="5974767339591067210">"Sistemi Android"</string>
    <string name="user_owner_label" msgid="8628726904184471211">"Kalo te profili personal"</string>
    <string name="managed_profile_label" msgid="7316778766973512382">"Kalo te profili i punës"</string>
    <string name="permgrouplab_contacts" msgid="4254143639307316920">"Kontaktet"</string>
    <string name="permgroupdesc_contacts" msgid="9163927941244182567">"qasu te kontaktet e tua"</string>
    <string name="permgrouprequest_contacts" msgid="7755354139254094668">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të ketë qasje te kontaktet e tua?"</string>
    <string name="permgrouplab_location" msgid="1858277002233964394">"Vendndodhja"</string>
    <string name="permgroupdesc_location" msgid="1995955142118450685">"qaset te vendndodhja e kësaj pajisjeje"</string>
    <string name="permgrouprequest_location" msgid="5261379525646615507">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të ketë qasje te vendndodhja e kësaj pajisjeje?"</string>
    <string name="permgrouprequestdetail_location" msgid="8223089637855613805">"Aplikacioni do të ketë qasje te vendndodhja vetëm kur po e përdor aplikacionin"</string>
    <string name="permgroupbackgroundrequest_location" msgid="534202103935528927">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të qaset te vendndodhja e kësaj pajisjeje &lt;b&gt;gjatë të gjithë kohës&lt;/b&gt;?"</string>
    <string name="permgroupbackgroundrequestdetail_location" msgid="5230541171285233536">"Aplikacioni aktualisht mund të qaset te vendndodhja vetëm kur ti e përdor aplikacionin"</string>
    <string name="permgrouplab_calendar" msgid="6426860926123033230">"Kalendari"</string>
    <string name="permgroupdesc_calendar" msgid="6762751063361489379">"qasje te kalendari yt"</string>
    <string name="permgrouprequest_calendar" msgid="2680538977344557840">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të ketë qasje te kalendari yt?"</string>
    <string name="permgrouplab_sms" msgid="795737735126084874">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="5726462398070064542">"dërgo dhe shiko mesazhet SMS"</string>
    <string name="permgrouprequest_sms" msgid="3985338150822482831">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të dërgojë dhe të shikojë mesazhet SMS?"</string>
    <string name="permgrouplab_storage" msgid="1121695277384787841">"Hapësira e ruajtjes"</string>
    <string name="permgroupdesc_storage" msgid="6351503740613026600">"qasjen te fotografitë, përmbajtjet audio-vizuale dhe skedarët në pajisje"</string>
    <string name="permgrouprequest_storage" msgid="1594774620878445266">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të ketë qasje te fotografitë, media dhe skedarët në pajisjen tënde?"</string>
    <string name="permgrouplab_microphone" msgid="2480597427667420076">"Mikrofoni"</string>
    <string name="permgroupdesc_microphone" msgid="1047786732792487722">"regjistro audio"</string>
    <string name="permgrouprequest_microphone" msgid="4942966684471718126">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të regjistrojë audio?"</string>
    <string name="permgrouplab_activityRecognition" msgid="3324466667921775766">"Aktiviteti fizik"</string>
    <string name="permgroupdesc_activityRecognition" msgid="4725624819457670704">"qasje në aktivitetin tënd fizik"</string>
    <string name="permgrouprequest_activityRecognition" msgid="693328554262727556">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të ketë qasje në aktivitetin tënd fizik?"</string>
    <string name="permgrouplab_camera" msgid="9090413408963547706">"Kamera"</string>
    <string name="permgroupdesc_camera" msgid="7585150538459320326">"bëj fotografi dhe regjistro video"</string>
    <string name="permgrouprequest_camera" msgid="2697305443703328372">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të nxjerrë fotografi dhe të regjistrojë video?"</string>
    <string name="permgrouplab_calllog" msgid="7926834372073550288">"Evidencat e telefonatave"</string>
    <string name="permgroupdesc_calllog" msgid="2026996642917801803">"lexo dhe shkruaj evidencën e telefonatave"</string>
    <string name="permgrouprequest_calllog" msgid="7565344038959817408">"Të lejohet &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të ketë qasje në evidencat e tua të telefonatave?"</string>
    <string name="permgrouplab_phone" msgid="570318944091926620">"Telefoni"</string>
    <string name="permgroupdesc_phone" msgid="270048070781478204">"kryej dhe menaxho telefonata"</string>
    <string name="permgrouprequest_phone" msgid="6430085454721364373">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të kryejë dhe të menaxhojë telefonata?"</string>
    <string name="permgrouplab_sensors" msgid="9134046949784064495">"Sensorët e trupit"</string>
    <string name="permgroupdesc_sensors" msgid="2610631290633747752">"qasu tek të dhënat e sensorëve rreth shenjave të tua jetësore"</string>
    <string name="permgrouprequest_sensors" msgid="2431000833343586816">"Të lejohet që &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; të ketë qasje te të dhënat e sensorëve rreth shenjave të tua jetësore?"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="7554282892101587296">"Nxjerrë përmbajtjen e dritares"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="6195610527625237661">"Inspekton përmbajtjen e dritares me të cilën po ndërvepron."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="327598364696316213">"Aktivizojë funksionin \"Eksploro me prekje\""</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="4394677060796752976">"Artikujt e trokitur do të lexohen me zë të lartë dhe ekrani mund të eksplorohet duke përdorur gjestet."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2772371671541753254">"Vëzhgojë tekstin që shkruan"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="2381315802405773092">"Përfshi të dhënat personale si numrat e kartave të kreditit si dhe fjalëkalimet."</string>
    <string name="capability_title_canControlMagnification" msgid="7701572187333415795">"Kontrollo zmadhimin e ekranit"</string>
    <string name="capability_desc_canControlMagnification" msgid="2206586716709254805">"Kontrollo nivelin dhe pozicionimin e zmadhimit të ekranit."</string>
    <string name="capability_title_canPerformGestures" msgid="9106545062106728987">"Kryen gjeste"</string>
    <string name="capability_desc_canPerformGestures" msgid="6619457251067929726">"Mund të trokasë, rrëshqasë, bashkojë gishtat dhe kryejë gjeste të tjera."</string>
    <string name="capability_title_canCaptureFingerprintGestures" msgid="1189053104594608091">"Gjestet e gjurmës së gishtit"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="6861869337457461274">"Mund të regjistrojë gjestet e kryera në sensorin e gjurmës së gishtit të pajisjes."</string>
    <string name="permlab_statusBar" msgid="8798267849526214017">"çaktivizo ose modifiko shiritin e statusit"</string>
    <string name="permdesc_statusBar" msgid="5809162768651019642">"Lejon aplikacionin të çaktivizojë shiritin e statusit dhe të heqë ikonat e sistemit."</string>
    <string name="permlab_statusBarService" msgid="2523421018081437981">"të bëhet shiriti i statusit"</string>
    <string name="permdesc_statusBarService" msgid="6652917399085712557">"Lejon aplikacionin të bëhet shiriti i statusit."</string>
    <string name="permlab_expandStatusBar" msgid="1184232794782141698">"zgjero ose shpalos shiritin e statusit"</string>
    <string name="permdesc_expandStatusBar" msgid="7180756900448498536">"Lejon aplikacionin të zgjerojë ose shpalosë shiritin e statusit."</string>
    <string name="permlab_install_shortcut" msgid="7451554307502256221">"instalo shkurtore"</string>
    <string name="permdesc_install_shortcut" msgid="4476328467240212503">"Lejon një aplikacion për të shtuar shkurtore në ekranin bazë pa ndërhyrjen e përdoruesit."</string>
    <string name="permlab_uninstall_shortcut" msgid="295263654781900390">"çinstalo shkurtore"</string>
    <string name="permdesc_uninstall_shortcut" msgid="1924735350988629188">"Lejon aplikacionin të heqë shkurtore në ekranin bazë, pa ndërhyrjen e përdoruesit."</string>
    <string name="permlab_processOutgoingCalls" msgid="4075056020714266558">"ridrejto telefonatat dalëse"</string>
    <string name="permdesc_processOutgoingCalls" msgid="7833149750590606334">"Lejon aplikacionin të shohë numrin që telefonohet gjatë një telefonate dalëse me opsionin për ta ri-orientuar telefonatën drejt një numri tjetër ose për ta ndërprerë plotësisht telefonatën."</string>
    <string name="permlab_answerPhoneCalls" msgid="4131324833663725855">"përgjigjju telefonatave"</string>
    <string name="permdesc_answerPhoneCalls" msgid="894386681983116838">"Lejon që aplikacioni t\'i përgjigjet një telefonate hyrëse."</string>
    <string name="permlab_receiveSms" msgid="505961632050451881">"merr mesazhe me tekst (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="1797345626687832285">"Lejon aplikacionin të marrë dhe përpunojë mesazhe SMS. Kjo do të thotë se aplikacioni mund të monitorojë ose fshijë mesazhe të dërguara në pajisjen tënde, pa t\'i treguar ato."</string>
    <string name="permlab_receiveMms" msgid="4000650116674380275">"prano mesazhe në tekst (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="958102423732219710">"Lejon aplikacionin të marrë dhe përpunojë mesazhe MMS. Kjo do të thotë se aplikacioni mund të monitorojë ose fshijë mesazhe të dërguara në pajisjen tënde, pa t\'i treguar ato."</string>
    <string name="permlab_readCellBroadcasts" msgid="5869884450872137693">"lexo mesazhet e transmetimit të qelizës"</string>
    <string name="permdesc_readCellBroadcasts" msgid="672513437331980168">"Lejon aplikacionin të lexojë mesazhet e transmetimit të qelizës, të marra nga pajisja jote. Alarmet e transmetimit të qelizës dërgohen në disa vendndodhje për të të paralajmëruar në situata urgjente. Aplikacionet keqdashëse mund të ndërhyjnë në veprimtarinë ose operacionin e pajisjes tënde kur merret një transmetim urgjent i qelizës."</string>
    <string name="permlab_subscribedFeedsRead" msgid="217624769238425461">"lexo informacione të abonuara"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="6911349196661811865">"Lejon aplikacionin të marrë detaje rreth çdo gjëje që sinkronizohet në pajisje."</string>
    <string name="permlab_sendSms" msgid="7757368721742014252">"dërgo dhe shiko mesazhet SMS"</string>
    <string name="permdesc_sendSms" msgid="6757089798435130769">"Lejon aplikacionin të dërgojë mesazhe SMS. Kjo mund të rezultojë me tarifa të papritura. Aplikacionet keqdashëse mund të të kushtojnë të holla duke dërguar mesazhe pa konfirmimin tënd."</string>
    <string name="permlab_readSms" msgid="5164176626258800297">"lexo mesazhet e tua në tekst (SMS ose MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="7912990447198112829">"Ky aplikacion mund të lexojë të gjitha mesazhet SMS (me tekst) të ruajtura në tabletin tënd."</string>
    <string name="permdesc_readSms" product="tv" msgid="8967963387951154530">"Ky aplikacion mund të lexojë të gjitha mesazhet SMS (me tekst) të ruajtura në televizorin tënd."</string>
    <string name="permdesc_readSms" product="default" msgid="774753371111699782">"Ky aplikacion mund të lexojë të gjitha mesazhet SMS (me tekst) të ruajtura në telefonin tënd."</string>
    <string name="permlab_receiveWapPush" msgid="4223747702856929056">"merr mesazhe me tekst (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="1638677888301778457">"Lejon aplikacionin të marrë dhe përpunojë mesazhe WAP. Kjo do të thotë se aplikacioni mund të monitorojë ose fshijë mesazhe të dërguara në pajisjen tënde, pa t\'i treguar ato."</string>
    <string name="permlab_getTasks" msgid="7460048811831750262">"gjej aplikacionet në punë"</string>
    <string name="permdesc_getTasks" msgid="7388138607018233726">"Lejon aplikacionin të gjejë informacione mbi detyrat aktuale dhe të fundit në punë. Kjo mund të lejojë aplikacionin të zbulojë informacione rreth aplikacioneve të përdorura në pajisje."</string>
    <string name="permlab_manageProfileAndDeviceOwners" msgid="639849495253987493">"menaxho zotëruesit e profilit dhe të pajisjes"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="7304240671781989283">"Lejo aplikacionet që të caktojnë pronarët e profilit dhe pronarin e pajisjes"</string>
    <string name="permlab_reorderTasks" msgid="7598562301992923804">"ri-poziciono aplikacionet në punë"</string>
    <string name="permdesc_reorderTasks" msgid="8796089937352344183">"Lejon aplikacionin të zhvendosë detyra në plan të parë dhe në sfond. Aplikacioni mund ta bëjë këtë pa hyrjen tënde."</string>
    <string name="permlab_enableCarMode" msgid="893019409519325311">"aktivizo modalitetin \"në makinë\""</string>
    <string name="permdesc_enableCarMode" msgid="56419168820473508">"Lejon aplikacionin të aktivizojë modalitetin e makinës."</string>
    <string name="permlab_killBackgroundProcesses" msgid="6559320515561928348">"mbylli aplikacionet e tjera"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="2357013583055434685">"Lejon aplikacionin t\'u japë fund proceseve në sfond të aplikacioneve të tjera. Kjo mund të shkaktojë mosfunksionimin e aplikacioneve të tjera."</string>
    <string name="permlab_systemAlertWindow" msgid="5757218350944719065">"Ky aplikacion mund të shfaqet mbi aplikacionet e tjera"</string>
    <string name="permdesc_systemAlertWindow" msgid="1145660714855738308">"Ky aplikacion mund të shfaqet mbi aplikacionet e tjera ose në pjesë të tjera të ekranit. Kjo mund të shkaktojë ndërhyrje në përdorimin normal të aplikacionit dhe në mënyrën se si shfaqen aplikacionet e tjera."</string>
    <string name="permlab_runInBackground" msgid="541863968571682785">"ekzekuto në sfond"</string>
    <string name="permdesc_runInBackground" msgid="4344539472115495141">"Ky aplikacion mund të ekzekutohet në sfond. Kjo mund ta shkarkojë më shpejt baterinë."</string>
    <string name="permlab_useDataInBackground" msgid="783415807623038947">"përdor të dhënat në sfond"</string>
    <string name="permdesc_useDataInBackground" msgid="1230753883865891987">"Ky aplikacion mund të përdorë të dhënat në sfond. Kjo mund të rritë përdorimin e të dhënave."</string>
    <string name="permlab_persistentActivity" msgid="464970041740567970">"bëje aplikacionin të qëndrojë gjithmonë në punë"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="6055271149187369916">"Lejon aplikacionin të zaptojë një pjesë të qëndrueshme në kujtesë. Kjo mund të kufizojë kujtesën e disponueshme për aplikacionet e tjera duke e ngadalësuar tabletin."</string>
    <string name="permdesc_persistentActivity" product="tv" msgid="2616944406357387366">"Lejon aplikacionin të zaptojë një pjesë të qëndrueshme në kujtesë. Kjo mund të kufizojë kujtesën e disponueshme për aplikacionet e tjera duke e ngadalësuar televizorin."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="1914841924366562051">"Lejon aplikacionin të zaptojë një pjesë të qëndrueshme në kujtesë. Kjo mund të kufizojë kujtesën e disponueshme për aplikacionet e tjera duke e ngadalësuar telefonin."</string>
    <string name="permlab_foregroundService" msgid="1768855976818467491">"ekzekuto shërbimin në plan të parë"</string>
    <string name="permdesc_foregroundService" msgid="8720071450020922795">"Lejon aplikacionin të përdorë shërbimet në plan të parë."</string>
    <string name="permlab_getPackageSize" msgid="375391550792886641">"mat hapësirën ruajtëse të aplikacionit"</string>
    <string name="permdesc_getPackageSize" msgid="742743530909966782">"Lejon aplikacionin të gjejë kodin e tij, të dhënat dhe madhësitë e memorieve të përkohshme."</string>
    <string name="permlab_writeSettings" msgid="8057285063719277394">"modifiko cilësimet e sistemit"</string>
    <string name="permdesc_writeSettings" msgid="8293047411196067188">"Lejon aplikacionin të modifikojë të dhënat e cilësimeve të sistemit. Aplikacionet keqdashëse mund të prishin konfigurimin e sistemit."</string>
    <string name="permlab_receiveBootCompleted" msgid="6643339400247325379">"nise në fillim"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="5565659082718177484">"Lejon aplikacionin të fillojë vetë sapo sistemi ka mbaruar nisjen. Kjo mund të zgjasë kohën e ngritjes së tabletit dhe të lejojë aplikacionin të ngadalësojë veprimtarinë në përgjithësi, duke qenë gjithmonë në punë."</string>
    <string name="permdesc_receiveBootCompleted" product="tv" msgid="2701244540810970401">"Lejon aplikacionin të fillojë vetë sapo sistemi ka mbaruar nisjen. Kjo mund të zgjasë kohën e ngritjes së televizorit dhe të lejojë aplikacionin të ngadalësojë veprimtarinë në përgjithësi, duke qenë gjithmonë në punë."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="7912677044558690092">"Lejon aplikacionin të fillojë vetë sapo sistemi të ketë mbaruar nisjen. Kjo mund të zgjasë kohën e ngritjes së telefonit dhe të lejojë aplikacionin të ngadalësojë përgjithësisht telefonin duke qëndruar gjithnjë në punë."</string>
    <string name="permlab_broadcastSticky" msgid="4552241916400572230">"dërgo transmetim të ngjitur"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="5058486069846384013">"Lejon aplikacionin të dërgojë transmetime ngjitëse që qëndrojnë derisa të përfundojë transmetimi. Përdorimi i tepruar mund ta bëjë tabletin të ngadaltë ose të paqëndrueshëm duke e detyruar atë të përdorë shumë kujtesë."</string>
    <string name="permdesc_broadcastSticky" product="tv" msgid="4148011273011857829">"Lejon aplikacionin të dërgojë transmetime ngjitëse të cilat ngelen pas mbarimit të transmetimit. Përdorimi i tepërt mund ta bëjë televizorin të ngadaltë ose të paqëndrueshëm, duke e detyruar atë të përdorë më shumë kujtesë."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="134529339678913453">"Lejon aplikacionin të dërgojë transmetime ngjitëse që qëndrojnë derisa të përfundojë transmetimi. Përdorimi i tepruar mund ta bëjë telefonin të ngadaltë ose të paqëndrueshëm duke e detyruar atë të përdorë shumë kujtesë."</string>
    <string name="permlab_readContacts" msgid="8776395111787429099">"lexo kontaktet e tua"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="80783131858366692">"Lejon aplikacionin të lexojë të dhëna për kontaktet e ruajtura në tabletin tënd. Kjo leje lejon që aplikacionet të ruajnë të dhënat e tua të kontakteve dhe aplikacionet keqdashëse mund të ndajnë të dhëna të kontakteve pa dijeninë tënde."</string>
    <string name="permdesc_readContacts" product="tv" msgid="4930202526885367788">"Lejon aplikacionin të lexojë të dhëna për kontaktet e ruajtura në televizorin tënd. Kjo leje lejon që aplikacionet të ruajnë të dhënat e tua të kontakteve dhe aplikacionet keqdashëse mund të ndajnë të dhëna të kontakteve pa dijeninë tënde."</string>
    <string name="permdesc_readContacts" product="default" msgid="6808717801527690363">"Lejon aplikacionin të lexojë të dhëna për kontaktet e ruajtura në telefonin tënd. Kjo leje lejon që aplikacionet të ruajnë të dhënat e tua të kontakteve dhe aplikacionet keqdashëse mund të ndajnë të dhëna të kontakteve pa dijeninë tënde."</string>
    <string name="permlab_writeContacts" msgid="8919430536404830430">"modifiko kontaktet"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="6422419281427826181">"Lejon aplikacionin të modifikojë të dhënat rreth kontakteve të tua të ruajtura në tabletin tënd. Kjo leje lejon që aplikacionet të fshijnë të dhënat e kontakteve."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="7554829984159606156">"Lejon aplikacionin të modifikojë të dhënat rreth kontakteve të tua të ruajtura në televizorin tënd. Kjo leje lejon që aplikacionet të fshijnë të dhënat e kontakteve."</string>
    <string name="permdesc_writeContacts" product="default" msgid="8304795696237065281">"Lejon aplikacionin të modifikojë të dhënat rreth kontakteve të tua të ruajtura në telefonin tënd. Kjo leje lejon që aplikacionet të fshijnë të dhënat e kontakteve."</string>
    <string name="permlab_readCallLog" msgid="1739990210293505948">"lexo ditarin e telefonatave"</string>
    <string name="permdesc_readCallLog" msgid="8964770895425873433">"Ky aplikacion mund të lexojë të gjithë historikun e telefonatave."</string>
    <string name="permlab_writeCallLog" msgid="670292975137658895">"shkruaj ditarin e telefonatave"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="2657525794731690397">"Lejon aplikacionin të modifikojë ditarin e telefonatave të tabletit tënd, përfshirë të dhëna rreth telefonatave hyrëse dhe dalëse. Aplikacione keqdashëse mund ta përdorin këtë leje për të fshirë ose modifikuar ditarin tënd të telefonatave."</string>
    <string name="permdesc_writeCallLog" product="tv" msgid="220754624705969171">"Lejon aplikacionin të modifikojë ditarin e telefonatave të televizorit tënd, përfshirë të dhëna rreth telefonatave hyrëse dhe dalëse. Aplikacione keqdashëse mund ta përdorin këtë leje për të fshirë ose modifikuar ditarin tënd të telefonatave."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="5903033505665134802">"Lejon aplikacionin të modifikojë ditarin e telefonatave të telefonit tënd, përfshirë të dhënat rreth telefonatave hyrëse dhe dalëse. Aplikacionet keqdashëse mund ta përdorin këtë për të fshirë ose modifikuar ditarin tënd të telefonatave."</string>
    <string name="permlab_bodySensors" msgid="3411035315357380862">"qasu te sensorët e trupit (si monitorimet e rrahjeve të zemrës)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="2365357960407973997">"Lejon aplikacionin të ketë qasje në të dhënat nga ndjesorë që monitorojnë gjendjen tënde fizike, siç janë rrahjet e zemrës."</string>
    <string name="permlab_readCalendar" msgid="6408654259475396200">"Lexo ngjarjet e kalendarit dhe detajet"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="515452384059803326">"Ky aplikacion mund të lexojë të gjitha ngjarjet e kalendarit të ruajtura në tabletin tënd dhe të ndajë ose të ruajë të dhënat e kalendarit."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="4359404686228921749">"Ky aplikacion mund të lexojë të gjitha ngjarjet e kalendarit të ruajtura në televizorin tënd dhe të ndajë ose të ruajë të dhënat e kalendarit."</string>
    <string name="permdesc_readCalendar" product="default" msgid="9118823807655829957">"Ky aplikacion mund të lexojë të gjitha ngjarjet e kalendarit të ruajtura në telefonin tënd dhe të ndajë ose të ruajë të dhënat e kalendarit."</string>
    <string name="permlab_writeCalendar" msgid="6422137308329578076">"shto ose modifiko ngjarjet e kalendarit dhe dërgoju email të ftuarve pa dijeninë e zotëruesve"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="8722230940717092850">"Ky aplikacion mund të shtojë, të heqë ose të ndryshojë ngjarjet e kalendarit në tabletin tënd. Ky aplikacion mund të dërgojë mesazhe që mund të duket se vijnë nga zotëruesit e kalendarit ose të ndryshojë ngjarjet pa i njoftuar zotëruesit e tyre."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="6841397610226826926">"Ky aplikacion mund të shtojë, të heqë ose të ndryshojë ngjarjet e kalendarit në televizorin tënd. Ky aplikacion mund të dërgojë mesazhe që mund të duket se vijnë nga zotëruesit e kalendarit ose të ndryshojë ngjarjet pa i njoftuar zotëruesit e tyre."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="5416380074475634233">"Ky aplikacion mund të shtojë, të heqë ose të ndryshojë ngjarjet e kalendarit në telefonin tënd. Ky aplikacion mund të dërgojë mesazhe që mund të duket se vijnë nga zotëruesit e kalendarit ose të ndryshojë ngjarjet pa i njoftuar zotëruesit e tyre."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="5162339812057983988">"qasje në komandat shtesë të ofruesit të vendndodhjes"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="355369611979907967">"Lejon aplikacionin të ketë qasje në komandat shtesë të ofruesit për vendndodhjen. Kjo mund ta lejojë aplikacionin të ndërhyjë në operacionin e GPS-së apo të burimeve të tjera për vendndodhjen."</string>
    <string name="permlab_accessFineLocation" msgid="6426318438195622966">"qasu në vendndodhjen e saktë vetëm në plan të parë"</string>
    <string name="permdesc_accessFineLocation" msgid="3056141052532120237">"Ky aplikacion mund të marrë vendndodhjen tënde të saktë në çdo kohë kur është në plan të parë. Këto shërbime të vendndodhjes duhet të jenë të aktivizuara dhe në dispozicion në telefonin tënd që aplikacioni të mund t\'i përdorë. Kjo gjë mund të rritë konsumin e baterisë."</string>
    <string name="permlab_accessCoarseLocation" msgid="8215351553392299056">"qasu te vendndodhja e përafërt (bazuar te rrjeti) vetëm në plan të parë"</string>
    <string name="permdesc_accessCoarseLocation" product="tablet" msgid="7479449026750078899">"Ky aplikacion mund të marrë vendndodhjen tënde bazuar në burimet e rrjetit si antenat e operatorëve celulare dhe rrjetet Wi-Fi, por vetëm kur aplikacioni është në plan të parë. Këto shërbime të vendndodhjes duhet të jenë të aktivizuara dhe të ofrohen në tabletin tënd që aplikacioni të mund t\'i përdorë."</string>
    <string name="permdesc_accessCoarseLocation" product="tv" msgid="1912601926375190585">"Ky aplikacion mund të marrë vendndodhjen tënde bazuar në burimet e rrjetit si antenat e operatorëve celulare dhe rrjetet Wi-Fi, por vetëm kur aplikacioni është në plan të parë. Këto shërbime të vendndodhjes duhet të jenë të aktivizuara dhe të ofrohen në televizorin tënd që aplikacioni të mund t\'i përdorë."</string>
    <string name="permdesc_accessCoarseLocation" product="automotive" msgid="2154996109427085674">"Ky aplikacion mund të marrë vendndodhjen tënde të përafërt vetëm kur është në plan të parë. Këto shërbime të vendndodhjes duhet të jenë të aktivizuara dhe të ofrohen në makinën tënde që aplikacioni të mund t\'i përdorë."</string>
    <string name="permdesc_accessCoarseLocation" product="default" msgid="8962998102400124341">"Ky aplikacion mund të marrë vendndodhjen tënde bazuar në burimet e rrjetit si antenat e operatorëve celulare dhe rrjetet Wi-Fi, por vetëm kur aplikacioni është në plan të parë. Këto shërbime të vendndodhjes duhet të jenë të aktivizuara dhe të ofrohen në telefonin tënd që aplikacioni të mund t\'i përdorë."</string>
    <string name="permlab_accessBackgroundLocation" msgid="1721164702777366138">"qasje te vendndodhja në sfond"</string>
    <string name="permdesc_accessBackgroundLocation" msgid="6904788108073882096">"Nëse kjo jepet përveç qasjes te vendndodhja e përafërt ose të saktë, aplikacioni mund të qaset te vendndodhja ndërkohë që ekzekutohet në sfond."</string>
    <string name="permlab_modifyAudioSettings" msgid="6129039778010031815">"ndrysho cilësimet e audios"</string>
    <string name="permdesc_modifyAudioSettings" msgid="8687227609663124921">"Lejon aplikacionin të modifikojë cilësimet globale të audios siç është volumi dhe se cili altoparlant përdoret për daljen."</string>
    <string name="permlab_recordAudio" msgid="1208457423054219147">"regjistro audio"</string>
    <string name="permdesc_recordAudio" msgid="3976213377904701093">"Ky aplikacion mund të regjistrojë audio me mikrofonin në çdo kohë."</string>
    <string name="permlab_sim_communication" msgid="176788115994050692">"dërgo komanda te karta SIM"</string>
    <string name="permdesc_sim_communication" msgid="4179799296415957960">"Lejon aplikacionin t\'i dërgojë komanda kartës SIM. Kjo është shumë e rrezikshme."</string>
    <string name="permlab_activityRecognition" msgid="1782303296053990884">"njih aktivitetin fizik"</string>
    <string name="permdesc_activityRecognition" msgid="8667484762991357519">"Ky aplikacion mund të njohë aktivitetin tënd fizik."</string>
    <string name="permlab_camera" msgid="6320282492904119413">"bëj fotografi dhe video"</string>
    <string name="permdesc_camera" msgid="1354600178048761499">"Ky aplikacion mund të nxjerrë fotografi dhe të regjistrojë video me kamerën tënde në çdo kohë."</string>
    <string name="permlab_vibrate" msgid="8596800035791962017">"kontrollo dridhjen"</string>
    <string name="permdesc_vibrate" msgid="8733343234582083721">"Lejon aplikacionin të kontrollojë dridhësin."</string>
    <string name="permlab_callPhone" msgid="1798582257194643320">"telefono drejtpërdrejt numrat e telefonit"</string>
    <string name="permdesc_callPhone" msgid="5439809516131609109">"Lejon aplikacionin të telefonojë numra pa ndërhyrjen tënde. Kjo mund të rezultojë në tarifa ose telefonata të papritura. Ki parasysh se kjo nuk e lejon aplikacionin të telefonojë numra urgjence. Aplikacione keqdashëse mund të të kushtojnë para duke kryer telefonata pa konfirmimin tënd."</string>
    <string name="permlab_accessImsCallService" msgid="442192920714863782">"qasje në shërbimin e telefonatave IMS"</string>
    <string name="permdesc_accessImsCallService" msgid="6328551241649687162">"Lejon aplikacionin të përdorë shërbimin IMS për të kryer telefonata pa ndërhyrjen tënde."</string>
    <string name="permlab_readPhoneState" msgid="8138526903259297969">"lexo statusin e telefonit dhe identitetin"</string>
    <string name="permdesc_readPhoneState" msgid="7229063553502788058">"Lejon aplikacionin të hyjë në funksionet telefonike të pajisjes. Kjo leje i mundëson aplikacionit të përcaktojë numrin e telefonit dhe ID-të e pajisjes, nëse një telefonatë është aktive apo nëse numri në distancë është i lidhur me një telefonatë."</string>
    <string name="permlab_manageOwnCalls" msgid="9033349060307561370">"kalon telefonatat përmes sistemit"</string>
    <string name="permdesc_manageOwnCalls" msgid="4431178362202142574">"Lejon që aplikacioni të kalojë telefonatat përmes sistemit për të përmirësuar përvojën e telefonatës."</string>
    <string name="permlab_callCompanionApp" msgid="3654373653014126884">"Shiko dhe kontrollo telefonatat nëpërmjet sistemit."</string>
    <string name="permdesc_callCompanionApp" msgid="8474168926184156261">"Lejon që aplikacioni të shikojë dhe të kontrollojë telefonatat në vazhdim në pajisje. Kjo përfshin informacione si p.sh. numrat e telefonatave për telefonatat dhe gjendjen e telefonatave."</string>
    <string name="permlab_acceptHandover" msgid="2925523073573116523">"vazhdo një telefonatë nga një aplikacion tjetër"</string>
    <string name="permdesc_acceptHandovers" msgid="7129026180128626870">"Lejon që aplikacioni të vazhdojë një telefonatë që është nisur në një aplikacion tjetër."</string>
    <string name="permlab_readPhoneNumbers" msgid="5668704794723365628">"lexo numrat e telefonit"</string>
    <string name="permdesc_readPhoneNumbers" msgid="7368652482818338871">"Lejon që aplikacioni të ketë qasje te numrat e telefonit të pajisjes."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1527660973931694000">"parandalo kalimin e tabletit në fjetje"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2597122827869353116">"parandalo kalimin e televizorit në fjetje"</string>
    <string name="permlab_wakeLock" product="default" msgid="569409726861695115">"parandalo kalimin e telefonit në fjetje"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="2441742939101526277">"Lejon aplikacionin të parandalojë tabletin nga fjetja."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="7562330010764851191">"Lejon aplikacionin të parandalojë televizorin nga fjetja."</string>
    <string name="permdesc_wakeLock" product="default" msgid="3689523792074007163">"Lejon aplikacionin të parandalojë telefonin nga fjetja."</string>
    <string name="permlab_transmitIr" msgid="8077196086358004010">"transmeto rreze infra të kuqe"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5884738958581810253">"Lejon aplikacionin të përdorë transmetuesin e rrezeve infra të kuqe të tabletit."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="4453220932790148184">"Lejon aplikacionin të përdorë transmetuesin e rrezeve infra të kuqe të sistemit."</string>
    <string name="permdesc_transmitIr" product="default" msgid="8484193849295581808">"Lejon aplikacionin të përdorë transmetuesin e rrezeve infra të kuqe të telefonit."</string>
    <string name="permlab_setWallpaper" msgid="6959514622698794511">"cakto imazhin e sfondit"</string>
    <string name="permdesc_setWallpaper" msgid="2973996714129021397">"Lejon aplikacionin të caktojë imazhin e sfondit të sistemit."</string>
    <string name="permlab_setWallpaperHints" msgid="1153485176642032714">"përshtat madhësinë e imazhit të sfondit"</string>
    <string name="permdesc_setWallpaperHints" msgid="6257053376990044668">"Lejon aplikacionin të caktojë treguesit e imazheve të sfondit në sistem."</string>
    <string name="permlab_setTimeZone" msgid="7922618798611542432">"cakto brezin orar"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1788868809638682503">"Lejon aplikacionin të ndryshojë brezin orar të tabletit."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="1000749751269030813">"Lejon aplikacionin të ndryshojë brezin orar të televizorit."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4611828585759488256">"Lejon aplikacionin të ndryshojë brezin orar të telefonit."</string>
    <string name="permlab_getAccounts" msgid="5304317160463582791">"gjej llogari në pajisje"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="1784452755887604512">"Lejon aplikacionin të marrë listën e llogarive të njohura nga tableti. Kjo mund të përfshijë çdo llogari të krijuar nga aplikacionet që ke instaluar."</string>
    <string name="permdesc_getAccounts" product="tv" msgid="3233589616751852028">"Lejon aplikacionin të marrë listën e llogarive të njohura nga televizori. Kjo mund të përfshijë çdo llogari të krijuar nga aplikacionet që ke instaluar."</string>
    <string name="permdesc_getAccounts" product="default" msgid="2491273043569751867">"Lejon aplikacionin të marrë listën e llogarive të njohura nga telefoni. Kjo mund të përfshijë çdo llogari të krijuar nga aplikacionet që ke instaluar."</string>
    <string name="permlab_accessNetworkState" msgid="2349126720783633918">"shiko lidhjet e rrjetit"</string>
    <string name="permdesc_accessNetworkState" msgid="4394564702881662849">"Lejon aplikacionin të shohë informacionin rreth lidhjeve të rrjetit, se çfarë rrjetesh ekzistojnë dhe janë të lidhur."</string>
    <string name="permlab_createNetworkSockets" msgid="3224420491603590541">"qasu plotësisht në rrjet"</string>
    <string name="permdesc_createNetworkSockets" msgid="7722020828749535988">"Lejon aplikacionin të krijojë fole rrjeti dhe të përdorë protokolle të personalizuara në të. Shfletuesi dhe aplikacionet e tjera sigurojnë mënyra për të dërguar të dhëna në internet, prandaj kjo leje nuk kërkohet për të dërguar të dhëna në internet."</string>
    <string name="permlab_changeNetworkState" msgid="8945711637530425586">"ndrysho lidhjen e rrjetit"</string>
    <string name="permdesc_changeNetworkState" msgid="649341947816898736">"Lejon aplikacionin të ndryshojë gjendjen e lidhjes së rrjetit."</string>
    <string name="permlab_changeTetherState" msgid="9079611809931863861">"ndrysho lidhjen e kufizuar"</string>
    <string name="permdesc_changeTetherState" msgid="3025129606422533085">"Lejon aplikacionin të ndryshojë gjendjen e lidhjes së rrjetit."</string>
    <string name="permlab_accessWifiState" msgid="5552488500317911052">"shiko lidhjet Wi-Fi"</string>
    <string name="permdesc_accessWifiState" msgid="6913641669259483363">"Lejon aplikacionin të shohë informacionin rreth rrjetit Wi-Fi, nëse Wi-Fi është i aktivizuar dhe emrin e pajisjeve të lidhura me Wi-Fi."</string>
    <string name="permlab_changeWifiState" msgid="7947824109713181554">"lidhu ose shkëputu nga Wi-Fi"</string>
    <string name="permdesc_changeWifiState" msgid="7170350070554505384">"Lejon aplikacionin të lidhet me pikat e qasjes Wi-Fi, të shkëputet prej tyre dhe të bëjë ndryshime në konfigurimin e pajisjes për rrjetet Wi-Fi."</string>
    <string name="permlab_changeWifiMulticastState" msgid="285626875870754696">"lejo marrjen e transmetimit të shumëfishtë Wi-Fi"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="191079868596433554">"Lejon aplikacionin të marrë paketa të dërguara në të gjitha pajisjet brenda një rrjeti Wi-Fi duke përdorur adresa me transferim të shumëfishtë, jo vetëm me tabletin tënd. Përdor më shumë energji se modaliteti \"jo me transferim të shumëfishtë\"."</string>
    <string name="permdesc_changeWifiMulticastState" product="tv" msgid="1253281508485111166">"Lejon aplikacionin të marrë paketa të dërguara në të gjitha pajisjet brenda një rrjeti Wi-Fi duke përdorur adresa me transferim të shumëfishtë, jo vetëm me televizorin tënd. Përdor më shumë energji se modaliteti \"jo me transferim të shumëfishtë\"."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="8296627590220222740">"Lejon aplikacionin të marrë paketa, të dërguara ndaj gjithë pajisjeve në një rrjet Wi-Fi duke përdorur adresa me transmetim të shumëfishtë, jo vetëm të telefonit tënd. Ai konsumon më tepër energji se modaliteti \"jo me transmetim të shumëfishtë\"."</string>
    <string name="permlab_bluetoothAdmin" msgid="6490373569441946064">"qasu në cilësimet e \"bluetooth-it\""</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="5370837055438574863">"Lejon aplikacionin të konfigurojë tabletin lokal me \"bluetooth\" dhe të zbulojë e çiftohet me pajisjet në distancë."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="1822785266335294155">"Lejon aplikacionin të konfigurojë televizorin lokal përmes \"bluetooth-it\" dhe të zbulojë e të çiftohet me pajisje në distancë."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="7381341743021234863">"Lejon aplikacionin të konfigurojë telefonin lokal \"bluetooth\" dhe të zbulojë e çiftohet me pajisjet në distancë."</string>
    <string name="permlab_accessWimaxState" msgid="7029563339012437434">"lidhu dhe shkëputu nga WiMAX"</string>
    <string name="permdesc_accessWimaxState" msgid="5372734776802067708">"Lejon aplikacionin të përcaktojë nëse WiMAX është i aktivizuar si dhe të mësojë informacion rreth ndonjë rrjeti të lidhur WiMAX."</string>
    <string name="permlab_changeWimaxState" msgid="6223305780806267462">"ndrysho gjendjen WiMAX"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="4011097664859480108">"Lejon aplikacionin ta lidhë tabletin dhe ta shkëpusë atë nga rrjetet WiMAX."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="6876948244710106021">"Lejon aplikacionin të lidhet me televizorin dhe ta shkëpusë atë nga rrjetet WiMAX."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="1551666203780202101">"Lejon aplikacionin të lidhet me telefonin dhe ta shkëpusë atë nga rrjetet WiMAX."</string>
    <string name="permlab_bluetooth" msgid="586333280736937209">"çifto me pajisjet me \"bluetooth\""</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3053222571491402635">"Lejon aplikacionin të shikojë konfigurimin e \"bluetooth-it\" në tablet, të kryejë dhe të pranojë lidhje me pajisjet e çiftuara."</string>
    <string name="permdesc_bluetooth" product="tv" msgid="3546625329740068213">"Lejon aplikacionin të shikojë konfigurimin e \"bluetooth-it\" në televizor, të kryejë dhe pranojë lidhje me pajisje të çiftuara."</string>
    <string name="permdesc_bluetooth" product="default" msgid="2779606714091276746">"Lejon aplikacionin të shohë konfigurimin e \"bluetooth-it\" në telefon dhe të kryejë e pranojë lidhje me pajisjet e çiftuara."</string>
    <string name="permlab_nfc" msgid="1904455246837674977">"kontrollo \"Komunikimin e fushës në afërsi\" NFC"</string>
    <string name="permdesc_nfc" msgid="8352737680695296741">"Lejon aplikacionin të komunikojë me etiketimet e \"Komunikimit të fushës së afërt (NFC)\", kartat dhe lexuesit."</string>
    <string name="permlab_disableKeyguard" msgid="3605253559020928505">"çaktivizo kyçjen e ekranit"</string>
    <string name="permdesc_disableKeyguard" msgid="3223710003098573038">"Lejon aplikacionin të çaktivizojë kyçjen e tasteve dhe çdo mbrojtje të lidhur me fjalëkalimin. Për shembull, telefoni çaktivizon kyçjen e tasteve kur merr një telefonatë hyrëse, pastaj riaktivizon kyçjen e tasteve kur mbaron telefonata."</string>
    <string name="permlab_requestPasswordComplexity" msgid="1808977190557794109">"kërko kompleksitetin e kyçjes së ekranit"</string>
    <string name="permdesc_requestPasswordComplexity" msgid="1130556896836258567">"Lejo që aplikacioni të mësojë nivelin e kompleksitetit të kyçjes së ekranit (i lartë, i mesëm, i ulët ose asnjë), që tregon gamën e mundshme të gjatësisë dhe llojin e kyçjes së ekranit. Aplikacioni mund t\'u sugjerojë gjithashtu përdoruesve që të përditësojnë kyçjen e ekranit në një nivel të caktuar, por përdoruesit mund ta shpërfillin lirshëm dhe të navigojnë më tej. Ki parasysh se kyçja e ekranit nuk ruhet në tekst të thjeshtë, prandaj aplikacioni nuk e di fjalëkalimin e saktë."</string>
    <string name="permlab_useBiometric" msgid="6314741124749633786">"përdor harduerin biometrik"</string>
    <string name="permdesc_useBiometric" msgid="7502858732677143410">"E lejon aplikacionin që të përdorë harduerin biometrik për vërtetimin"</string>
    <string name="permlab_manageFingerprint" msgid="7432667156322821178">"të menaxhojë harduerin e gjurmës së gishtit"</string>
    <string name="permdesc_manageFingerprint" msgid="2025616816437339865">"E lejon aplikacionin që të aktivizojë metoda për të shtuar dhe për të fshirë shabllonet e gjurmës së gishtit për përdorim."</string>
    <string name="permlab_useFingerprint" msgid="1001421069766751922">"përdor harduerin e gjurmës së gishtit"</string>
    <string name="permdesc_useFingerprint" msgid="412463055059323742">"E lejon aplikacionin që të përdorë harduerin e gjurmës së gishtit për verifikim"</string>
    <string name="permlab_audioWrite" msgid="8501705294265669405">"modifiko koleksionin tënd të muzikës"</string>
    <string name="permdesc_audioWrite" msgid="8057399517013412431">"Lejon aplikacionin të modifikojë koleksionin tënd të muzikës."</string>
    <string name="permlab_videoWrite" msgid="5940738769586451318">"modifiko koleksionin tënd të videove"</string>
    <string name="permdesc_videoWrite" msgid="6124731210613317051">"Lejon aplikacionin të modifikojë koleksionin tënd të videove."</string>
    <string name="permlab_imagesWrite" msgid="1774555086984985578">"modifiko koleksionin tënd të fotografive"</string>
    <string name="permdesc_imagesWrite" msgid="5195054463269193317">"Lejon aplikacionin të modifikojë koleksionin tënd të fotografive."</string>
    <string name="permlab_mediaLocation" msgid="7368098373378598066">"lexo vendndodhjet nga koleksioni yt i medias"</string>
    <string name="permdesc_mediaLocation" msgid="597912899423578138">"Lejon aplikacionin të lexojë vendndodhjet nga koleksioni yt i medias."</string>
    <string name="biometric_dialog_default_title" msgid="5284880398508155088">"Verifiko që je ti"</string>
    <string name="biometric_error_hw_unavailable" msgid="2494077380540615216">"Nuk ofrohet harduer biometrik"</string>
    <string name="biometric_error_user_canceled" msgid="6732303949695293730">"Vërtetimi u anulua"</string>
    <string name="biometric_not_recognized" msgid="5106687642694635888">"Nuk njihet"</string>
    <string name="biometric_error_canceled" msgid="8266582404844179778">"Vërtetimi u anulua"</string>
    <string name="biometric_error_device_not_secured" msgid="3129845065043995924">"Nuk është vendosur kod PIN, motiv ose fjalëkalim"</string>
    <string name="fingerprint_acquired_partial" msgid="8532380671091299342">"U zbulua një gjurmë gishti e pjesshme. Provo përsëri."</string>
    <string name="fingerprint_acquired_insufficient" msgid="2545149524031515411">"Gjurma e gishtit nuk mund të përpunohej. Provo përsëri."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="4694800187151533990">"Sensori i gjurmës së gishtit nuk është i pastër. Pastroje dhe provo përsëri."</string>
    <string name="fingerprint_acquired_too_fast" msgid="5151661932298844352">"Gishti lëvizi shumë shpejt. Provo përsëri."</string>
    <string name="fingerprint_acquired_too_slow" msgid="6683510291554497580">"Gishti lëvizi shumë ngadalë. Provo përsëri."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_authenticated" msgid="2024862866860283100">"Gjurma e gishtit u vërtetua"</string>
    <string name="face_authenticated_no_confirmation_required" msgid="8867889115112348167">"Fytyra u vërtetua"</string>
    <string name="face_authenticated_confirmation_required" msgid="6872632732508013755">"Fytyra u vërtetua, shtyp \"Konfirmo\""</string>
    <string name="fingerprint_error_hw_not_available" msgid="4571700896929561202">"Hardueri i gjurmës së gishtit nuk mundësohet."</string>
    <string name="fingerprint_error_no_space" msgid="6126456006769817485">"Gjurma e gishtit nuk mund të ruhet. Hiq një gjurmë gishti ekzistuese."</string>
    <string name="fingerprint_error_timeout" msgid="2946635815726054226">"Koha e veprimit për gjurmën e gishtit skadoi. Provo përsëri."</string>
    <string name="fingerprint_error_canceled" msgid="540026881380070750">"Operacioni i gjurmës së gishtit u anulua."</string>
    <string name="fingerprint_error_user_canceled" msgid="7685676229281231614">"Veprimi i gjurmës së gishtit u anulua nga përdoruesi."</string>
    <string name="fingerprint_error_lockout" msgid="7853461265604738671">"Keni bërë shumë tentativa. Provo përsëri më vonë."</string>
    <string name="fingerprint_error_lockout_permanent" msgid="3895478283943513746">"Shumë përpjekje. Sensori i gjurmës së gishtit u çaktivizua."</string>
    <string name="fingerprint_error_unable_to_process" msgid="1148553603490048742">"Provo përsëri."</string>
    <string name="fingerprint_error_no_fingerprints" msgid="8671811719699072411">"Nuk ka asnjë gjurmë gishti të regjistruar."</string>
    <string name="fingerprint_error_hw_not_present" msgid="578914350967423382">"Kjo pajisje nuk ka sensor të gjurmës së gishtit."</string>
    <string name="fingerprint_name_template" msgid="8941662088160289778">"Gishti <xliff:g id="FINGERID">%d</xliff:g>"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="fingerprint_icon_content_description" msgid="4741068463175388817">"Ikona e gjurmës së gishtit"</string>
    <string name="permlab_manageFace" msgid="4569549381889283282">"menaxho harduerin për shkyçjen me fytyrën"</string>
    <string name="permdesc_manageFace" msgid="6204569688492710471">"Lejon aplikacionin të aktivizojë mënyra për shtim e fshirje të shablloneve të përdorura."</string>
    <string name="permlab_useFaceAuthentication" msgid="1011430526454859030">"përdor harduerin e shkyçjes me fytyrën"</string>
    <string name="permdesc_useFaceAuthentication" msgid="3115697017684668012">"Lejon aplikacionin të përdorë harduerin e shkyçjes me fytyrën për procesin e vërtetimit"</string>
    <string name="face_recalibrate_notification_name" msgid="6006095897989257026">"Shkyçja me fytyrë"</string>
    <string name="face_recalibrate_notification_title" msgid="5944930528030496897">"Regjistro përsëri fytyrën tënde"</string>
    <string name="face_recalibrate_notification_content" msgid="892757485125249962">"Për të përmirësuar njohjen, regjistro përsëri fytyrën tënde"</string>
    <string name="face_acquired_insufficient" msgid="2150805835949162453">"S\'mund të regjistroheshin të dhëna të sakta të fytyrës. Provo përsëri."</string>
    <string name="face_acquired_too_bright" msgid="8070756048978079164">"Me shumë ndriçim. Provo një ndriçim më të butë."</string>
    <string name="face_acquired_too_dark" msgid="252573548464426546">"Shumë i errët. Provo një ndriçim më të fortë."</string>
    <string name="face_acquired_too_close" msgid="1628767882971469833">"Lëvize telefonin më larg."</string>
    <string name="face_acquired_too_far" msgid="5098567726427173896">"Afroje telefonin."</string>
    <string name="face_acquired_too_high" msgid="4868033653626081839">"Ngrije telefonin më lart."</string>
    <string name="face_acquired_too_low" msgid="1512237819632165945">"Ule telefonin më poshtë."</string>
    <string name="face_acquired_too_right" msgid="2513391513020932655">"Lëvize telefonin majtas."</string>
    <string name="face_acquired_too_left" msgid="8882499346502714350">"Lëvize telefonin djathtas"</string>
    <string name="face_acquired_poor_gaze" msgid="4427153558773628020">"Shiko më drejt në pajisjen tënde."</string>
    <string name="face_acquired_not_detected" msgid="2945945257956443257">"Pozicionoje fytyrën tënde direkt përpara telefonit."</string>
    <string name="face_acquired_too_much_motion" msgid="8199691445085189528">"Ka shumë lëvizje. Mbaje telefonin të palëvizur."</string>
    <string name="face_acquired_recalibrate" msgid="8724013080976469746">"Regjistroje përsëri fytyrën tënde."</string>
    <string name="face_acquired_too_different" msgid="4699657338753282542">"Fytyra nuk mund të njihet më. Provo përsëri."</string>
    <string name="face_acquired_too_similar" msgid="7684650785108399370">"Tepër e ngjashme, ndrysho pozën"</string>
    <string name="face_acquired_pan_too_extreme" msgid="7822191262299152527">"Ktheje kokën pak më pak."</string>
    <string name="face_acquired_tilt_too_extreme" msgid="8119978324129248059">"Ktheje kokën pak më pak."</string>
    <string name="face_acquired_roll_too_extreme" msgid="1442830503572636825">"Ktheje kokën pak më pak."</string>
    <string name="face_acquired_obscured" msgid="4917643294953326639">"Hiq gjithçka që fsheh fytyrën tënde."</string>
    <string name="face_acquired_sensor_dirty" msgid="8968391891086721678">"Pastro kreun e ekranit, duke përfshirë shiritin e zi"</string>
  <string-array name="face_acquired_vendor">
  </string-array>
    <string name="face_error_hw_not_available" msgid="5085202213036026288">"Fytyra s\'mund të verifikohet. Hardueri nuk ofrohet."</string>
    <string name="face_error_timeout" msgid="522924647742024699">"Provo përsëri shkyçjen me fytyrën."</string>
    <string name="face_error_no_space" msgid="5649264057026021723">"S\'mund të ruhen të dhëna të reja fytyre. Fshi një të vjetër në fillim."</string>
    <string name="face_error_canceled" msgid="2164434737103802131">"Veprimi me fytyrën u anulua."</string>
    <string name="face_error_user_canceled" msgid="8553045452825849843">"Shkyçja me fytyrë u anulua nga përdoruesi."</string>
    <string name="face_error_lockout" msgid="7864408714994529437">"Shumë përpjekje. Provo sërish më vonë."</string>
    <string name="face_error_lockout_permanent" msgid="8277853602168960343">"Shumë përpjekje. Shkyçja me fytyrë u çaktivizua."</string>
    <string name="face_error_unable_to_process" msgid="5723292697366130070">"Fytyra nuk mund të verifikohet. Provo përsëri."</string>
    <string name="face_error_not_enrolled" msgid="7369928733504691611">"Nuk e ke konfiguruar shkyçjen me fytyrë."</string>
    <string name="face_error_hw_not_present" msgid="1070600921591729944">"Shkyçja me fytyrë nuk mbështetet në këtë pajisje"</string>
    <string name="face_name_template" msgid="3877037340223318119">"Fytyra <xliff:g id="FACEID">%d</xliff:g>"</string>
  <string-array name="face_error_vendor">
  </string-array>
    <string name="face_icon_content_description" msgid="465030547475916280">"Ikona e fytyrës"</string>
    <string name="permlab_readSyncSettings" msgid="6250532864893156277">"lexo cilësimet e sinkronizimit"</string>
    <string name="permdesc_readSyncSettings" msgid="1325658466358779298">"Lejon aplikacionin të lexojë cilësimet e sinkronizimit për një llogari. Për shembull, kjo mund të përcaktojë nëse aplikacioni \"Kontaktet\" është i sinkronizuar me një llogari."</string>
    <string name="permlab_writeSyncSettings" msgid="6583154300780427399">"ndiz ose fik sinkronizimin"</string>
    <string name="permdesc_writeSyncSettings" msgid="6029151549667182687">"Lejon një aplikacion të modifikojë cilësimet e sinkronizimit për një llogari. Për shembull, kjo mund të përdoret për të mundësuar sinkronizimin e aplikacionit \"Kontaktet\" me një llogari."</string>
    <string name="permlab_readSyncStats" msgid="3747407238320105332">"lexo statistikat e sinkronizimit"</string>
    <string name="permdesc_readSyncStats" msgid="3867809926567379434">"Lejon një aplikacion të lexojë statistikat e sinkronizimit për një llogari, përfshirë historikun e ngjarjeve të sinkronizimit dhe se sa të dhëna janë sinkronizuar."</string>
    <string name="permlab_sdcardRead" msgid="5791467020950064920">"lexo përmbajtjet e hapësirës ruajtëse të ndarë"</string>
    <string name="permdesc_sdcardRead" msgid="6872973242228240382">"Lejon aplikacionin të lexojë përmbajtjet e hapësirës ruajtëse të ndarë."</string>
    <string name="permlab_sdcardWrite" msgid="4863021819671416668">"modifiko ose fshi përmbajtjet e hapësirës ruajtëse të ndarë"</string>
    <string name="permdesc_sdcardWrite" msgid="8376047679331387102">"Lejon që aplikacioni të shkruajë përmbajtjet e hapësirës ruajtëse të ndarë."</string>
    <string name="permlab_use_sip" msgid="8250774565189337477">"bëj/merr telefonata SIP"</string>
    <string name="permdesc_use_sip" msgid="3590270893253204451">"Lejon aplikacionin të kryejë dhe të marrë telefonata SIP."</string>
    <string name="permlab_register_sim_subscription" msgid="1653054249287576161">"regjistro lidhje të reja telekomunikimi të kartës SIM"</string>
    <string name="permdesc_register_sim_subscription" msgid="4183858662792232464">"Lejon aplikacionin të regjistrojë lidhje të reja telekomunikimi të kartës SIM."</string>
    <string name="permlab_register_call_provider" msgid="6135073566140050702">"regjistro lidhjet e reja të telekomunikimit"</string>
    <string name="permdesc_register_call_provider" msgid="4201429251459068613">"Lejon aplikacionin të regjistrojë lidhje të reja telekomunikimi."</string>
    <string name="permlab_connection_manager" msgid="3179365584691166915">"menaxho lidhjet e telekomunikimit"</string>
    <string name="permdesc_connection_manager" msgid="1426093604238937733">"Lejon aplikacionin të menaxhojë lidhjet e telekomunikimit."</string>
    <string name="permlab_bind_incall_service" msgid="5990625112603493016">"bashkëvepro me ekranin gjatë telefonatës"</string>
    <string name="permdesc_bind_incall_service" msgid="4124917526967765162">"Lejon aplikacionin të kontrollojë kur dhe si përdoruesi e shikon ekranin e telefonatës."</string>
    <string name="permlab_bind_connection_service" msgid="5409268245525024736">"bashkëvepro me shërbimet telefonike"</string>
    <string name="permdesc_bind_connection_service" msgid="6261796725253264518">"Lejon aplikacionin të bashkëveprojë me shërbimet telefonike për të kryer/marrë telefonata."</string>
    <string name="permlab_control_incall_experience" msgid="6436863486094352987">"ofro një përvojë përdoruesi mbi telefonatat"</string>
    <string name="permdesc_control_incall_experience" msgid="5896723643771737534">"Lejon aplikacionin të ofrojë përvojë përdoruesi mbi telefonatat."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="8470402862501573795">"lexo përdorimin kronologjik të rrjetit"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="1112962304941637102">"Lejon aplikacionin të lexojë përdorimin historik të rrjetit, për rrjete dhe aplikacione të veçantë."</string>
    <string name="permlab_manageNetworkPolicy" msgid="6872549423152175378">"menaxho politikën e rrjetit"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="1865663268764673296">"Lejon aplikacionin të menaxhojë politikat e rrjetit dhe të përcaktojë rregullat të veçanta aplikacioni."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="7448790834938749041">"modifiko llogaritjen e përdorimit të rrjetit"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5076042642247205390">"Lejon aplikacionin të modifikojë si llogaritet përdorimi i rrjetit përkundrejt aplikacioneve. Nuk përdoret nga aplikacionet normale."</string>
    <string name="permlab_accessNotifications" msgid="7130360248191984741">"qasju njoftimeve"</string>
    <string name="permdesc_accessNotifications" msgid="761730149268789668">"Lejon aplikacionin të gjejë, ekzaminojë dhe pastrojë njoftimet, përfshi edhe ato të postuara nga aplikacionet e tjera."</string>
    <string name="permlab_bindNotificationListenerService" msgid="5848096702733262458">"lidhu me një shërbim dëgjues të njoftimeve"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="4970553694467137126">"Lejon zotëruesin të lidhet me ndërfaqen e nivelit të lartë të një shërbimi për dëgjimin e njoftimeve. Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_bindConditionProviderService" msgid="5245421224814878483">"lidhu me një shërbim për ofrim kushtesh"</string>
    <string name="permdesc_bindConditionProviderService" msgid="6106018791256120258">"Lejon zotëruesin të lidhet me ndërfaqen e nivelit të lartë të një ofruesi shërbimi me kusht. Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_bindDreamService" msgid="4776175992848982706">"lidhu me një shërbim mbrojtësi ekrani \"dream\""</string>
    <string name="permdesc_bindDreamService" msgid="9129615743300572973">"Lejon zotëruesin të lidhet me ndërfaqen e nivelit më të lartë të një shërbimi \"dream\" (mbrojtësi ekrani). Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_invokeCarrierSetup" msgid="5098810760209818140">"kërko aplikacionin e konfigurimit të dhënë nga operatori"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4790845896063237887">"Lejon zotëruesin të aktivizojë aplikacionin e konfiguracionit të siguruar nga operatori. Nuk nevojitet nga aplikacionet normale."</string>
    <string name="permlab_accessNetworkConditions" msgid="1270732533356286514">"dëgjo për vërejtje në kushtet e rrjetit"</string>
    <string name="permdesc_accessNetworkConditions" msgid="2959269186741956109">"Lejon një aplikacion të dëgjojë vërejtjet mbi kushtet e rrjetit. Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_setInputCalibration" msgid="932069700285223434">"ndrysho kalibrimin e hyrjeve të pajisjes"</string>
    <string name="permdesc_setInputCalibration" msgid="2937872391426631726">"Lejon aplikacionin të modifikojë parametrat e kalibrimit të ekranit me prekje. Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_accessDrmCertificates" msgid="6473765454472436597">"qasje në certifikatat DRM"</string>
    <string name="permdesc_accessDrmCertificates" msgid="6983139753493781941">"Lejon një aplikacion të përgatisë dhe përdorë certifikatat DRM. Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_handoverStatus" msgid="7620438488137057281">"merr statusin e transferimit përmes \"Dërgimit me rreze të Android\""</string>
    <string name="permdesc_handoverStatus" msgid="3842269451732571070">"Lejon këtë aplikacion të marrë informacion rreth transferimeve aktuale \"Rrezja android\" (Android Beam)"</string>
    <string name="permlab_removeDrmCertificates" msgid="710576248717404416">"hiq certifikatat DRM"</string>
    <string name="permdesc_removeDrmCertificates" msgid="4068445390318355716">"Lejon një aplikacion të heqë certifikatat DRM. Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="3363450860593096967">"lidhu me një shërbim mesazhesh të operatorit"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="6316457028173478345">"Lejon zotëruesin të lidhet me ndërfaqen e nivelit të lartë të shërbimit të mesazheve të operatorit. Nuk nevojitet për aplikacione normale."</string>
    <string name="permlab_bindCarrierServices" msgid="2395596978626237474">"lidhu me shërbimet e operatorit celular"</string>
    <string name="permdesc_bindCarrierServices" msgid="9185614481967262900">"Lejon që mbajtësi të lidhet me shërbimet e operatorit celular. Nuk nevojitet për aplikacionet normale."</string>
    <string name="permlab_access_notification_policy" msgid="5524112842876975537">"qasje te \"Mos shqetëso\""</string>
    <string name="permdesc_access_notification_policy" msgid="8538374112403845013">"Lejon aplikacionin të lexojë dhe shkruajë konfigurimin e \"Mos shqetëso\"."</string>
    <string name="permlab_startViewPermissionUsage" msgid="1504564328641112341">"nis përdorimin e lejes për shikimin"</string>
    <string name="permdesc_startViewPermissionUsage" msgid="2820325605959586538">"Lejon që mbajtësi të nisë përdorimin e lejeve për një aplikacion. Nuk duhet të nevojitet asnjëherë për aplikacionet normale."</string>
    <string name="policylab_limitPassword" msgid="4851829918814422199">"Cakto rregullat e fjalëkalimit"</string>
    <string name="policydesc_limitPassword" msgid="4105491021115793793">"Kontrollo gjatësinë dhe karakteret e lejuara në fjalëkalimet dhe kodet PIN të kyçjes së ekranit."</string>
    <string name="policylab_watchLogin" msgid="7599669460083719504">"Monitoro tentativat e shkyçjes së ekranit"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="2388436408621909298">"Monitoro numrin e fjalëkalimeve të shkruar gabim kur shkyç ekranin. Kyç tabletin ose fshi të gjitha të dhënat e tij, nëse shkruhen shumë fjalëkalime të pasakta."</string>
    <string name="policydesc_watchLogin" product="TV" msgid="1880525102716729482">"Monitoro numrin e fjalëkalimeve të shkruara gabim kur shkyç ekranin. Kyç televizorin ose fshi të gjitha të dhënat e tij, nëse shkruhen shumë fjalëkalime të pasakta."</string>
    <string name="policydesc_watchLogin" product="default" msgid="4885030206253600299">"Monitoro numrin e fjalëkalimeve të shkruar gabim kur shkyç ekranin. Kyç telefonin ose fshi të gjitha të dhënat e tij, nëse shkruhen shumë fjalëkalime të pasakta."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet" msgid="2049038943004297474">"Monitoro numrin e fjalëkalimeve të shkruara gabim kur shkyç ekranin. Kyçe tabletin ose spastro të gjitha të dhënat e këtij përdoruesi nëse shkruhen shumë fjalëkalime të gabuara."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="TV" msgid="1253625325967736219">"Monitoro numrin e fjalëkalimeve të shkruara gabim kur shkyç ekranin. Kyçe televizorin ose spastro të gjitha të dhënat e këtij përdoruesi nëse shkruhen shumë fjalëkalime të gabuara."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="9177645136475155924">"Monitoro numrin e fjalëkalimeve të shkruara gabim kur shkyç ekranin. Kyçe telefonin ose spastro të gjitha të dhënat e këtij përdoruesi nëse shkruhen shumë fjalëkalime të gabuara."</string>
    <string name="policylab_resetPassword" msgid="214556238645096520">"Ndryshimin e kyçjes"</string>
    <string name="policydesc_resetPassword" msgid="4626419138439341851">"Ndryshon kyçjen e ekranit."</string>
    <string name="policylab_forceLock" msgid="7360335502968476434">"Kyçjen e ekranit"</string>
    <string name="policydesc_forceLock" msgid="1008844760853899693">"Kontrollon si dhe kur të kyçet ekrani."</string>
    <string name="policylab_wipeData" msgid="1359485247727537311">"Fshirjen e të dhënave"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="7245372676261947507">"Fshi të dhënat e tabletit pa paralajmërim duke kryer një rivendosje të të dhënave në gjendje fabrike."</string>
    <string name="policydesc_wipeData" product="tv" msgid="8755409895408717659">"Fshi të dhënat e televizorit pa paralajmërim duke kryer një rivendosje të të dhënave në gjendje fabrike."</string>
    <string name="policydesc_wipeData" product="default" msgid="8036084184768379022">"Fshin të dhënat e telefonit pa paralajmërim, duke kryer rivendosje të të dhënave në gjendje fabrike."</string>
    <string name="policylab_wipeData_secondaryUser" msgid="413813645323433166">"Spatro të dhënat e përdoruesit"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="2336676480090926470">"Spastroji të dhënat e këtij përdoruesi në këtë tablet pa paralajmërim."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="7310266499158746034">"Spastroji të dhënat e këtij përdoruesi në këtë televizor pa paralajmërim."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="2788325512167208654">"Spastroji të dhënat e këtij përdoruesi në këtë telefon pa paralajmërim."</string>
    <string name="policylab_setGlobalProxy" msgid="215332221188670221">"Cakto përfaqësuesin global të pajisjes"</string>
    <string name="policydesc_setGlobalProxy" msgid="7149665222705519604">"Cakto përfaqësuesin global të pajisjes që të përdoret kur të aktivizohet politika. Vetëm pronari i pajisjes mund ta caktojë përfaqësuesin global."</string>
    <string name="policylab_expirePassword" msgid="6015404400532459169">"Cakto skadimin e fjalëkalimit të kyçjes së ekranit"</string>
    <string name="policydesc_expirePassword" msgid="9136524319325960675">"Ndrysho se sa shpesh duhet të ndërrohet fjalëkalimi, kodi PIN ose modeli i kyçjes së ekranit."</string>
    <string name="policylab_encryptedStorage" msgid="9012936958126670110">"Cakto enkriptimin e hapësirës ruajtëse"</string>
    <string name="policydesc_encryptedStorage" msgid="1102516950740375617">"Kërko që të dhënat e ruajtura të aplikacionit të enkriptohen."</string>
    <string name="policylab_disableCamera" msgid="5749486347810162018">"Çaktivizo kamerat"</string>
    <string name="policydesc_disableCamera" msgid="3204405908799676104">"Parandalo përdorimin e të gjitha kamerave të pajisjes."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="5071855750149949741">"Çaktivizimin e disa funksioneve të kyçjes së ekranit"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="6641673177041195957">"Parandalo përdorimin e disa funksioneve të kyçjes së ekranit."</string>
  <string-array name="phoneTypes">
    <item msgid="8996339953292723951">"Shtëpia"</item>
    <item msgid="7740243458912727194">"Celulari"</item>
    <item msgid="8526146065496663766">"Puna"</item>
    <item msgid="8150904584178569699">"Faks pune"</item>
    <item msgid="4537253139152229577">"Faks shtëpie"</item>
    <item msgid="6751245029698664340">"Biper"</item>
    <item msgid="1692790665884224905">"Tjetër"</item>
    <item msgid="6216981255272016212">"E personalizuar"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="7786349763648997741">"Faqja e parë"</item>
    <item msgid="435564470865989199">"Puna"</item>
    <item msgid="4199433197875490373">"Tjetër"</item>
    <item msgid="3233938986670468328">"E personalizuar"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="3861463339764243038">"Shtëpia"</item>
    <item msgid="5472578890164979109">"Puna"</item>
    <item msgid="5718921296646594739">"Tjetër"</item>
    <item msgid="5523122236731783179">"E personalizuar"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="588088543406993772">"Shtëpia"</item>
    <item msgid="5503060422020476757">"Puna"</item>
    <item msgid="2530391194653760297">"Tjetër"</item>
    <item msgid="7640927178025203330">"I personalizuar"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="6144047813304847762">"Puna"</item>
    <item msgid="7402720230065674193">"Tjetër"</item>
    <item msgid="808230403067569648">"E personalizuar"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="7535761744432206400">"AIM"</item>
    <item msgid="2236558491789293993">"\"Windows Live\""</item>
    <item msgid="4925858989398000295">"Yahoo"</item>
    <item msgid="5203383604393320577">"Skype"</item>
    <item msgid="6142060795155127001">"QQ"</item>
    <item msgid="8831467252725610081">"Bisedo me Google"</item>
    <item msgid="4717545739447438044">"ICQ"</item>
    <item msgid="8293711853624033835">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="5120365721260686814">"E personalizuar"</string>
    <string name="phoneTypeHome" msgid="3880132427643623588">"Shtëpia"</string>
    <string name="phoneTypeMobile" msgid="1178852541462086735">"Celular"</string>
    <string name="phoneTypeWork" msgid="6604967163358864607">"Puna"</string>
    <string name="phoneTypeFaxWork" msgid="6757519896109439123">"Faks pune"</string>
    <string name="phoneTypeFaxHome" msgid="6678559953115904345">"Faks shtëpie"</string>
    <string name="phoneTypePager" msgid="576402072263522767">"Biper"</string>
    <string name="phoneTypeOther" msgid="6918196243648754715">"Tjetër"</string>
    <string name="phoneTypeCallback" msgid="3455781500844157767">"Ri-telefono"</string>
    <string name="phoneTypeCar" msgid="4604775148963129195">"Numri i telefonit të makinës"</string>
    <string name="phoneTypeCompanyMain" msgid="4482773154536455441">"Numri kryesor i telefonit të kompanisë"</string>
    <string name="phoneTypeIsdn" msgid="2496238954533998512">"ISDN"</string>
    <string name="phoneTypeMain" msgid="5199722006991000111">"Kryesor"</string>
    <string name="phoneTypeOtherFax" msgid="3037145630364770357">"Faks tjetër"</string>
    <string name="phoneTypeRadio" msgid="2637819130239264771">"Radio"</string>
    <string name="phoneTypeTelex" msgid="2558783611711876562">"Teleks"</string>
    <string name="phoneTypeTtyTdd" msgid="532038552105328779">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="7522314392003565121">"Celulari i punës"</string>
    <string name="phoneTypeWorkPager" msgid="3748332310638505234">"Biperi i punës"</string>
    <string name="phoneTypeAssistant" msgid="757550783842231039">"Ndihmësi"</string>
    <string name="phoneTypeMms" msgid="1799747455131365989">"MMS"</string>
    <string name="eventTypeCustom" msgid="3257367158986466481">"E personalizuar"</string>
    <string name="eventTypeBirthday" msgid="7770026752793912283">"Ditëlindje"</string>
    <string name="eventTypeAnniversary" msgid="4684702412407916888">"Përvjetor"</string>
    <string name="eventTypeOther" msgid="530671238533887997">"Tjetër"</string>
    <string name="emailTypeCustom" msgid="1809435350482181786">"I personalizuar"</string>
    <string name="emailTypeHome" msgid="1597116303154775999">"Shtëpia"</string>
    <string name="emailTypeWork" msgid="2020095414401882111">"Puna"</string>
    <string name="emailTypeOther" msgid="5131130857030897465">"Tjetër"</string>
    <string name="emailTypeMobile" msgid="787155077375364230">"Celulari"</string>
    <string name="postalTypeCustom" msgid="5645590470242939129">"E personalizuar"</string>
    <string name="postalTypeHome" msgid="7562272480949727912">"Shtëpia"</string>
    <string name="postalTypeWork" msgid="8553425424652012826">"Puna"</string>
    <string name="postalTypeOther" msgid="7094245413678857420">"Tjetër"</string>
    <string name="imTypeCustom" msgid="5653384545085765570">"E personalizuar"</string>
    <string name="imTypeHome" msgid="6996507981044278216">"Faqja e parë"</string>
    <string name="imTypeWork" msgid="2099668940169903123">"Puna"</string>
    <string name="imTypeOther" msgid="8068447383276219810">"Tjetër"</string>
    <string name="imProtocolCustom" msgid="4437878287653764692">"I personalizuar"</string>
    <string name="imProtocolAim" msgid="4050198236506604378">"AIM"</string>
    <string name="imProtocolMsn" msgid="2257148557766499232">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="5373338758093392231">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="1486297589164830043">"Skype"</string>
    <string name="imProtocolQq" msgid="7254708777029006592">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="9194016024343166782">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="2410325380427389521">"ICQ"</string>
    <string name="imProtocolJabber" msgid="7919269388889582015">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="4985002408136148256">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="8684458700669564172">"Puna"</string>
    <string name="orgTypeOther" msgid="5450675258408005553">"Tjetër"</string>
    <string name="orgTypeCustom" msgid="1126322047677329218">"E personalizuar"</string>
    <string name="relationTypeCustom" msgid="282938315217441351">"E personalizuar"</string>
    <string name="relationTypeAssistant" msgid="4057605157116589315">"Ndihmës"</string>
    <string name="relationTypeBrother" msgid="7141662427379247820">"Vëlla"</string>
    <string name="relationTypeChild" msgid="9076258911292693601">"Fëmijë"</string>
    <string name="relationTypeDomesticPartner" msgid="7825306887697559238">"Bashkëjetues"</string>
    <string name="relationTypeFather" msgid="3856225062864790596">"Baba"</string>
    <string name="relationTypeFriend" msgid="3192092625893980574">"Shok"</string>
    <string name="relationTypeManager" msgid="2272860813153171857">"Menaxher"</string>
    <string name="relationTypeMother" msgid="2331762740982699460">"Nënë"</string>
    <string name="relationTypeParent" msgid="4177920938333039882">"Prind"</string>
    <string name="relationTypePartner" msgid="4018017075116766194">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="5285082289602849400">"I referuar"</string>
    <string name="relationTypeRelative" msgid="3396498519818009134">"I afërm"</string>
    <string name="relationTypeSister" msgid="3721676005094140671">"Motër"</string>
    <string name="relationTypeSpouse" msgid="6916682664436031703">"Bashkëshort/e"</string>
    <string name="sipAddressTypeCustom" msgid="6283889809842649336">"E personalizuar"</string>
    <string name="sipAddressTypeHome" msgid="5918441930656878367">"Shtëpia"</string>
    <string name="sipAddressTypeWork" msgid="7873967986701216770">"Puna"</string>
    <string name="sipAddressTypeOther" msgid="6317012577345187275">"Tjetër"</string>
    <string name="quick_contacts_not_available" msgid="1262709196045052223">"Nuk u gjet asnjë aplikacion për të parë këtë kontakt."</string>
    <string name="keyguard_password_enter_pin_code" msgid="6401406801060956153">"Shkruaj kodin PIN"</string>
    <string name="keyguard_password_enter_puk_code" msgid="3112256684547584093">"Shkruaj PUK-un dhe PIN-in e ri"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="2825313071899938305">"Kodi PUK"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="5505434724229581207">"Kod i ri PIN"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="4032288032993261520"><font size="17">"Trokit për të shkruar fjalëkalimin"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="2751130557661643482">"Shkruaj fjalëkalimin për të shkyçur"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="7792964196473964340">"Shkruaj PIN-in për ta shkyçur"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="8583732939138432793">"Kodi PIN është i pasaktë."</string>
    <string name="keyguard_label_text" msgid="3841953694564168384">"Për të shkyçur, shtyp \"Meny\" pastaj 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="2978165477085612673">"Numri i urgjencës"</string>
    <string name="lockscreen_carrier_default" msgid="6192313772955399160">"Nuk ka shërbim"</string>
    <string name="lockscreen_screen_locked" msgid="7364905540516041817">"Ekrani është i kyçur."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="7982445492532123308">"Shtyp \"Meny\" për të shkyçur ose për të kryer telefonatë urgjence."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="7434061749374801753">"Shtyp \"Meny\" për të shkyçur."</string>
    <string name="lockscreen_pattern_instructions" msgid="3169991838169244941">"Vizato modelin për ta shkyçur"</string>
    <string name="lockscreen_emergency_call" msgid="7500692654885445299">"Urgjenca"</string>
    <string name="lockscreen_return_to_call" msgid="3156883574692006382">"Kthehu te telefonata"</string>
    <string name="lockscreen_pattern_correct" msgid="8050630103651508582">"Saktë!"</string>
    <string name="lockscreen_pattern_wrong" msgid="2940138714468358458">"Provo sërish"</string>
    <string name="lockscreen_password_wrong" msgid="8605355913868947490">"Provo sërish"</string>
    <string name="lockscreen_storage_locked" msgid="634993789186443380">"Shkyçe për të gjitha funksionet dhe të dhënat"</string>
    <string name="faceunlock_multiple_failures" msgid="681991538434031708">"Tentativat maksimale të \"Shkyçjes me fytyrë\" u tejkaluan"</string>
    <string name="lockscreen_missing_sim_message_short" msgid="1248431165144893792">"Nuk ka kartë SIM"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="8596805728510570760">"Nuk ka kartë SIM në tablet."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="1165408361036993077">"Nuk ka kartë SIM në televizor."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="1408695081255172556">"Nuk ka kartë SIM në telefon."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="8473601862688263903">"Fut një kartë SIM."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3664999892038416334">"Karta SIM mungon ose është e palexueshme. Fut një kartë të re SIM."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="3812893366715730539">"Karta SIM është e papërdorshme."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="4358929052509450807">"Karta jote SIM është çaktivizuar përgjithnjë.\n Kontakto ofruesin e shërbimit valor për një tjetër kartë SIM."</string>
    <string name="lockscreen_transport_prev_description" msgid="2879469521751181478">"Kënga e mëparshme"</string>
    <string name="lockscreen_transport_next_description" msgid="2931509904881099919">"Kënga tjetër"</string>
    <string name="lockscreen_transport_pause_description" msgid="6705284702135372494">"Pauzë"</string>
    <string name="lockscreen_transport_play_description" msgid="106868788691652733">"Luaj"</string>
    <string name="lockscreen_transport_stop_description" msgid="1449552232598355348">"Ndalo"</string>
    <string name="lockscreen_transport_rew_description" msgid="7680106856221622779">"Kthehu pas"</string>
    <string name="lockscreen_transport_ffw_description" msgid="4763794746640196772">"Përparo me shpejtësi"</string>
    <string name="emergency_calls_only" msgid="3057351206678279851">"Vetëm telefonata urgjente"</string>
    <string name="lockscreen_network_locked_message" msgid="2814046965899249635">"Rrjeti është i kyçur"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="6618356415831082174">"Karta SIM është e kyçur me PUK."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="5307979043730860995">"Shiko \"Manualin e përdorimit\" ose kontakto \"Kujdesin ndaj klientit\"."</string>
    <string name="lockscreen_sim_locked_message" msgid="3160196135801185938">"Karta SIM është e kyçur."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="2286497117428409709">"Po shkyç kartën SIM…"</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6458790975898594240">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për të vizatuar motivin tënd.\n\nProvo sërish për <xliff:g id="NUMBER_1">%2$d</xliff:g> sekonda."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="3118353451602377380">"E ke shkruar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë gabim fjalëkalimin. \n\nProvo sërish për <xliff:g id="NUMBER_1">%2$d</xliff:g> sekonda."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="2874278239714821984">"E ke shkruar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë gabimisht PIN-in tënd.\n\nProvo sërish për <xliff:g id="NUMBER_1">%2$d</xliff:g> sekonda."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="3069635524964070596">"Ke vizatuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë gabimisht motivin tënd të shkyçjes. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, do të të kërkohet ta shkyçësh tabletin duke përdorur identifikimin në Google.\n\n Provo sërish për <xliff:g id="NUMBER_2">%3$d</xliff:g> sekonda."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="8418060136796780268">"E ke vizatuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë gabimisht motivin tënd të shkyçjes. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme do të të kërkohet ta shkyçësh televizorin duke përdorur identifikimin në Google.\n\n Provo sërish për <xliff:g id="NUMBER_2">%3$d</xliff:g> sekonda."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="5691623136957148335">"Ke vizatuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë gabimisht motivin tënd të shkyçjes. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, do të të kërkohet ta shkyçësh telefonin duke përdorur identifikimin në Google.\n\n Provo sërish për <xliff:g id="NUMBER_2">%3$d</xliff:g> sekonda."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="7914445759242151426">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për ta shkyçur tabletin. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, tableti do të rivendoset në gjendjen e fabrikës dhe të gjitha të dhënat e përdoruesit do të humben."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv" msgid="2736747741914666082">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për ta shkyçur televizorin. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, televizori do të rivendoset në gjendjen e fabrikës dhe të gjitha të dhënat e përdoruesit do të humben."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="1166532464798446579">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për ta shkyçur telefonin. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, telefoni do të rivendoset në gjendjen e fabrikës dhe të gjitha të dhënat e përdoruesit do të humben."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="8682445539263683414">"Ke tentuar <xliff:g id="NUMBER">%d</xliff:g> herë pa sukses për ta shkyçur tabletin tënd. Tableti tani do të rivendoset në gjendje fabrike."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tv" msgid="2373955520011165432">"Ke tentuar <xliff:g id="NUMBER">%d</xliff:g> herë ta shkyçësh pa sukses televizorin tënd. Televizori do të rivendoset tani si në gjendjen e fabrikës."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="2203704707679895487">"Ke tentuar <xliff:g id="NUMBER">%d</xliff:g> herë ta shkyçësh pa sukses telefonin tënd. Telefoni do të rivendoset tani si në gjendjen e fabrikës."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6807200118164539589">"Provo sërish për <xliff:g id="NUMBER">%d</xliff:g> sekonda."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="8362442730606839031">"Harrove motivin?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="9218940117797602518">"Shkyçja e llogarisë"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="3775904917743034195">"Shumë tentativa për  motivin"</string>
    <string name="lockscreen_glogin_instructions" msgid="4695162942525531700">"Për ta shkyçur, identifikohu me llogarinë tënde të Google."</string>
    <string name="lockscreen_glogin_username_hint" msgid="6916101478673157045">"Emri i përdoruesit (mail-i)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="3031027901286812848">"Fjalëkalimi"</string>
    <string name="lockscreen_glogin_submit_button" msgid="3590556636347843733">"Identifikohu"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="4369219936865697679">"Emër përdoruesi ose fjalëkalim i pavlefshëm."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1683405808525090649">"Harrove emrin e përdoruesit apo fjalëkalimin?\nVizito "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="2607271802803381645">"Po kontrollon..."</string>
    <string name="lockscreen_unlock_label" msgid="4648257878373307582">"Shkyç"</string>
    <string name="lockscreen_sound_on_label" msgid="1660281470535492430">"Zëri u aktivizua"</string>
    <string name="lockscreen_sound_off_label" msgid="2331496559245450053">"Zëri është çaktivizuar"</string>
    <string name="lockscreen_access_pattern_start" msgid="3778502525702613399">"Motivi filloi"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="7493849102641167049">"Modeli u pastrua"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6746676335293144163">"Qeliza u shtua"</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="2931364927622563465">"Qeliza <xliff:g id="CELL_INDEX">%1$s</xliff:g> u shtua"</string>
    <string name="lockscreen_access_pattern_detected" msgid="3931150554035194012">"Modeli përfundoi"</string>
    <string name="lockscreen_access_pattern_area" msgid="1288780416685002841">"Zona e motivit."</string>
    <string name="keyguard_accessibility_widget_changed" msgid="7298011259508200234">"%1$s. Miniaplikacioni %2$d nga %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8245795023551343672">"Shto miniaplikacion."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="544239307077644480">"Bosh"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="7768634718706488951">"Zona e shkyçjes u zgjerua."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="4729922043778400434">"Zona e shkyçjes u shpalos."</string>
    <string name="keyguard_accessibility_widget" msgid="6776892679715699875">"<xliff:g id="WIDGET_INDEX">%1$s</xliff:g> i miniaplikacionit."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1466067610235696600">"Përzgjedhësi i përdoruesit"</string>
    <string name="keyguard_accessibility_status" msgid="6792745049712397237">"Statusi"</string>
    <string name="keyguard_accessibility_camera" msgid="7862557559464986528">"Kamera"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="2267379779900620614">"Kontrollet e klipeve \"media\""</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="7066213328912939191">"Filloi rirenditja e miniaplikacioneve."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="1083806817600593490">"Ri-renditja e miniaplikacioneve mbaroi."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="1509738950119878705">"Miniaplikacioni <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> u fshi."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="4215280881346033434">"Zgjero zonën e shkyçjes."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2968195219692413046">"Rrëshqit shkyçjen."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="8669128146589233293">"Shkyçje me motiv."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="632407612842329815">"Shkyçje me fytyrë."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="4020864007967340068">"Shkyçje me PIN."</string>
    <string name="keyguard_accessibility_sim_pin_unlock" msgid="4895939120871890557">"Shkyçja e kartës SIM me kodin PIN"</string>
    <string name="keyguard_accessibility_sim_puk_unlock" msgid="3459003464041899101">"Shkyçja e kartës SIM me kodin PUK"</string>
    <string name="keyguard_accessibility_password_unlock" msgid="6130186108581153265">"Shkyçja e fjalëkalimit."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="1419570880512350689">"Zona e motivit."</string>
    <string name="keyguard_accessibility_slide_area" msgid="4331399051142520176">"Zonën e rrëshqitjes."</string>
    <string name="password_keyboard_label_symbol_key" msgid="2716255580853511949">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="5294837425652726684">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="8528261816395508841">"ALT"</string>
    <string name="granularity_label_character" msgid="8903387663153706317">"karakter"</string>
    <string name="granularity_label_word" msgid="3686589158760620518">"fjalë"</string>
    <string name="granularity_label_link" msgid="9007852307112046526">"lidhje"</string>
    <string name="granularity_label_line" msgid="376204904280620221">"linjë"</string>
    <string name="factorytest_failed" msgid="3190979160945298006">"Testimi i fabrikës dështoi"</string>
    <string name="factorytest_not_system" msgid="5658160199925519869">"Veprimi i TESTIT_TË_FABRIKËS mbështetet vetëm për paketat e instaluara në /sistem/apl."</string>
    <string name="factorytest_no_action" msgid="339252838115675515">"Nuk u gjet asnjë paketë që siguron veprimin e TESTIT_TË_FABRIKËS."</string>
    <string name="factorytest_reboot" msgid="2050147445567257365">"Rifillo"</string>
    <string name="js_dialog_title" msgid="7464775045615023241">"Faqja në \"<xliff:g id="TITLE">%s</xliff:g>\" shkruan:"</string>
    <string name="js_dialog_title_default" msgid="3769524569903332476">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="7012587995876771246">"Konfirmo orientimin"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="4274257182303565509">"Largohu nga kjo faqe"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="3873765747622415310">"Qëndro në këtë faqe"</string>
    <string name="js_dialog_before_unload" msgid="7213364985774778744">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nJe i sigurt që do të largohesh nga kjo faqe?"</string>
    <string name="save_password_label" msgid="9161712335355510035">"Konfirmo"</string>
    <string name="double_tap_toast" msgid="7065519579174882778">"Këshillë! Trokit dy herë për të zmadhuar dhe zvogëluar."</string>
    <string name="autofill_this_form" msgid="3187132440451621492">"Plotësim automatik"</string>
    <string name="setup_autofill" msgid="5431369130866618567">"Konfiguro plotësuesin automatik"</string>
    <string name="autofill_window_title" msgid="4379134104008111961">"Plotëso automatikisht me <xliff:g id="SERVICENAME">%1$s</xliff:g>"</string>
    <string name="autofill_address_name_separator" msgid="8190155636149596125">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3402882515222673691">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="760522655085707045">", "</string>
    <string name="autofill_address_summary_format" msgid="8417010069362125194">"$1$2$3"</string>
    <string name="autofill_province" msgid="3676846437741893159">"Krahina"</string>
    <string name="autofill_postal_code" msgid="7034789388968295591">"Kodi postar"</string>
    <string name="autofill_state" msgid="3341725337190434069">"Shteti"</string>
    <string name="autofill_zip_code" msgid="1315503730274962450">"Kodi postar"</string>
    <string name="autofill_county" msgid="7781382735643492173">"Qarku"</string>
    <string name="autofill_island" msgid="5367139008536593734">"Ishulli"</string>
    <string name="autofill_district" msgid="6428712062213557327">"Rrethi"</string>
    <string name="autofill_department" msgid="9047276226873531529">"Departamenti"</string>
    <string name="autofill_prefecture" msgid="7267397763720241872">"Prefektura"</string>
    <string name="autofill_parish" msgid="6847960518334530198">"Famullia"</string>
    <string name="autofill_area" msgid="8289022370678448983">"Zona"</string>
    <string name="autofill_emirate" msgid="2544082046790551168">"Emirati"</string>
    <string name="permlab_readHistoryBookmarks" msgid="9102293913842539697">"lexo faqeshënuesit dhe historikun tënd në ueb"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="2323799501008967852">"Lejon aplikacionin të lexojë historikun e të gjitha URL-ve që ka vizituar shfletuesi dhe të gjitha faqet e ruajtura në shfletues. Shënim. Kjo leje nuk mund të zbatohet nga shfletues të palëve të treta ose aplikacione të tjera me aftësi për shfletim faqesh."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="6090259925187986937">"shkruaj faqeshënuesit dhe historikun në ueb"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="573341025292489065">"Lejon aplikacionin të modifikojë historikun e shfletuesit ose faqeve të ruajtur në tabletin tënd. Kjo mund ta lejojë aplikacionin të fshijë ose modifikojë të dhënat e shfletuesit. Shënim. Kjo leje mund të zbatohet nga shfletues të palëve të treta ose aplikacione me aftësi shfletimi faqesh."</string>
    <string name="permdesc_writeHistoryBookmarks" product="tv" msgid="755207379344494691">"Lejon aplikacionin të modifikojë historikun e shfletuesit ose faqeve të ruajtur në televizorin tënd. Kjo mund ta lejojë aplikacionin të fshijë ose modifikojë të dhënat e shfletuesit. Shënim. Kjo leje mund të zbatohet nga shfletues të palëve të treta ose aplikacione me aftësi shfletimi faqesh."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="2245203087160913652">"Lejon aplikacionin të modifikojë historikun e shfletuesit ose faqeve të ruajtur në telefonin tënd. Kjo mund ta lejojë aplikacionin të fshijë ose modifikojë të dhënat e shfletuesit. Shënim. Kjo leje mund të zbatohet nga shfletues të palëve të treta ose aplikacione me aftësi shfletimi faqesh."</string>
    <string name="permlab_setAlarm" msgid="1158001610254173567">"vendos alarm"</string>
    <string name="permdesc_setAlarm" msgid="2185033720060109640">"Lejon aplikacionin të vendosë një alarm në një aplikacion ore me alarm, i instaluar në pajisje. Disa aplikacione ore me alarm mund të mos e ekzekutojnë këtë funksion."</string>
    <string name="permlab_addVoicemail" msgid="4770245808840814471">"shto postë zanore"</string>
    <string name="permdesc_addVoicemail" msgid="5470312139820074324">"Lejon aplikacionin të shtojë mesazhe në kutinë e postës zanore."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="8605631647492879449">"modifiko lejet e shfletuesit për vendndodhjen gjeografike"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="5817346421222227772">"Lejon aplikacionin të modifikojë lejet e shfletuesit për vendndodhjen gjeografike. Aplikacionet keqdashëse mund ta përdorin këtë për të lejuar dërgimin e informacionit të vendndodhjes në faqe arbitrare uebi."</string>
    <string name="save_password_message" msgid="2146409467245462965">"Dëshiron që shfletuesi ta kujtojë këtë fjalëkalim?"</string>
    <string name="save_password_notnow" msgid="2878327088951240061">"Jo tani!"</string>
    <string name="save_password_remember" msgid="6490888932657708341">"Kujto"</string>
    <string name="save_password_never" msgid="6776808375903410659">"Asnjëherë"</string>
    <string name="open_permission_deny" msgid="5136793905306987251">"Nuk ke leje për ta hapur këtë faqe."</string>
    <string name="text_copied" msgid="2531420577879738860">"Teksti u kopjua në kujtesën e fragmenteve."</string>
    <string name="copied" msgid="4675902854553014676">"U kopjua"</string>
    <string name="more_item_label" msgid="7419249600215749115">"Më shumë"</string>
    <string name="prepend_shortcut_label" msgid="1743716737502867951">"Menyja+"</string>
    <string name="menu_meta_shortcut_label" msgid="1623390163674762478">"Meta+"</string>
    <string name="menu_ctrl_shortcut_label" msgid="131911133027196485">"Ctrl+"</string>
    <string name="menu_alt_shortcut_label" msgid="343761069945250991">"Alt+"</string>
    <string name="menu_shift_shortcut_label" msgid="5443936876111232346">"Shift+"</string>
    <string name="menu_sym_shortcut_label" msgid="4037566049061218776">"Sym+"</string>
    <string name="menu_function_shortcut_label" msgid="2367112760987662566">"Funksioni+"</string>
    <string name="menu_space_shortcut_label" msgid="5949311515646872071">"hapësirë"</string>
    <string name="menu_enter_shortcut_label" msgid="6709499510082897320">"enter"</string>
    <string name="menu_delete_shortcut_label" msgid="4365787714477739080">"fshi"</string>
    <string name="search_go" msgid="2141477624421347086">"Kërko"</string>
    <string name="search_hint" msgid="455364685740251925">"Kërko..."</string>
    <string name="searchview_description_search" msgid="1045552007537359343">"Kërko"</string>
    <string name="searchview_description_query" msgid="7430242366971716338">"Kërko pyetjen"</string>
    <string name="searchview_description_clear" msgid="1989371719192982900">"Pastro pyetjen"</string>
    <string name="searchview_description_submit" msgid="6771060386117334686">"Dërgo pyetjen"</string>
    <string name="searchview_description_voice" msgid="42360159504884679">"Kërkim me zë"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="5095399706284943314">"Të aktivizohet opsioni \"Eksploro me prekje\"?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="1037295476738940824">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> kërkon të aktivizojë funksionin \"Eksploro me prekje\". Kur aktivizohet \"Eksploro me prekje\", mund të dëgjosh ose të shohësh përshkrime se çfarë ka nën gishtin tënd ose të kryesh gjeste për të bashkëvepruar me tabletin."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="4312979647356179250">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> kërkon të aktivizojë funksionin \"Eksploro me prekje\". Kur aktivizohet \"Eksploro me prekje\", mund të dëgjosh ose të shohësh përshkrime se çfarë ka nën gishtin tënd ose të kryesh gjeste për të bashkëvepruar me telefonin."</string>
    <string name="oneMonthDurationPast" msgid="4538030857114635777">"1 muaj më parë"</string>
    <string name="beforeOneMonthDurationPast" msgid="8315149541372065392">"Para 1 muaji"</string>
    <plurals name="last_num_days" formatted="false" msgid="687443109145393632">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> ditët e fundit</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> ditën e fundit</item>
    </plurals>
    <string name="last_month" msgid="1528906781083518683">"Muajin e fundit"</string>
    <string name="older" msgid="1645159827884647400">"Më të vjetra"</string>
    <string name="preposition_for_date" msgid="2780767868832729599">"më <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="4336835286453822053">"në <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="3149809685340130039">"në <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8394717255950176156">"ditë"</string>
    <string name="days" msgid="4570879797423034973">"ditë"</string>
    <string name="hour" msgid="7796325297097314653">"orë"</string>
    <string name="hours" msgid="8517014849629200683">"orë"</string>
    <string name="minute" msgid="8369209540986467610">"minutë"</string>
    <string name="minutes" msgid="3456532942641808971">"minuta"</string>
    <string name="second" msgid="9210875257112211713">"sekondë"</string>
    <string name="seconds" msgid="2175052687727971048">"sekonda"</string>
    <string name="week" msgid="907127093960923779">"javë"</string>
    <string name="weeks" msgid="3516247214269821391">"javë"</string>
    <string name="year" msgid="5182610307741238982">"vit"</string>
    <string name="years" msgid="5797714729103773425">"vite"</string>
    <string name="now_string_shortest" msgid="3684914126941650330">"tani"</string>
    <plurals name="duration_minutes_shortest" formatted="false" msgid="7519574894537185135">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>m</item>
    </plurals>
    <plurals name="duration_hours_shortest" formatted="false" msgid="2838655994500499651">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>o</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>o</item>
    </plurals>
    <plurals name="duration_days_shortest" formatted="false" msgid="3686058472983158496">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest" formatted="false" msgid="8299112348723640338">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>v</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>v</item>
    </plurals>
    <plurals name="duration_minutes_shortest_future" formatted="false" msgid="849196137176399440">
      <item quantity="other">në <xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="one">në <xliff:g id="COUNT_0">%d</xliff:g>m</item>
    </plurals>
    <plurals name="duration_hours_shortest_future" formatted="false" msgid="5386373597343170388">
      <item quantity="other">në <xliff:g id="COUNT_1">%d</xliff:g>o</item>
      <item quantity="one">në <xliff:g id="COUNT_0">%d</xliff:g>o</item>
    </plurals>
    <plurals name="duration_days_shortest_future" formatted="false" msgid="814754627092787227">
      <item quantity="other">në <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="one">në <xliff:g id="COUNT_0">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest_future" formatted="false" msgid="7683731800140202145">
      <item quantity="other">në <xliff:g id="COUNT_1">%d</xliff:g>v</item>
      <item quantity="one">në <xliff:g id="COUNT_0">%d</xliff:g>v</item>
    </plurals>
    <plurals name="duration_minutes_relative" formatted="false" msgid="6569851308583028344">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> minuta më parë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> minutë më parë</item>
    </plurals>
    <plurals name="duration_hours_relative" formatted="false" msgid="420434788589102019">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> orë më parë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> orë më parë</item>
    </plurals>
    <plurals name="duration_days_relative" formatted="false" msgid="6056425878237482431">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> ditë më parë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> ditë më parë</item>
    </plurals>
    <plurals name="duration_years_relative" formatted="false" msgid="2179998228861172159">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> vite më parë</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> vit më parë</item>
    </plurals>
    <plurals name="duration_minutes_relative_future" formatted="false" msgid="5759885720917567723">
      <item quantity="other">për <xliff:g id="COUNT_1">%d</xliff:g> minuta</item>
      <item quantity="one">për <xliff:g id="COUNT_0">%d</xliff:g> minutë</item>
    </plurals>
    <plurals name="duration_hours_relative_future" formatted="false" msgid="8963511608507707959">
      <item quantity="other">për <xliff:g id="COUNT_1">%d</xliff:g> orë</item>
      <item quantity="one">për <xliff:g id="COUNT_0">%d</xliff:g> orë</item>
    </plurals>
    <plurals name="duration_days_relative_future" formatted="false" msgid="1964709470979250702">
      <item quantity="other">për <xliff:g id="COUNT_1">%d</xliff:g> ditë</item>
      <item quantity="one">për <xliff:g id="COUNT_0">%d</xliff:g> ditë</item>
    </plurals>
    <plurals name="duration_years_relative_future" formatted="false" msgid="3985129025134896371">
      <item quantity="other">për <xliff:g id="COUNT_1">%d</xliff:g> vite</item>
      <item quantity="one">për <xliff:g id="COUNT_0">%d</xliff:g> vit</item>
    </plurals>
    <string name="VideoView_error_title" msgid="5750686717225068016">"Problem me videon"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3782449246085134720">"Kjo video nuk ofrohet për transmetim në këtë pajisje."</string>
    <string name="VideoView_error_text_unknown" msgid="7658683339707607138">"Videoja nuk mund të luhet."</string>
    <string name="VideoView_error_button" msgid="5138809446603764272">"Në rregull"</string>
    <string name="relative_time" msgid="8572030016028033243">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="8365974533050605886">"mesditë"</string>
    <string name="Noon" msgid="6902418443846838189">"Mesditë"</string>
    <string name="midnight" msgid="3646671134282785114">"mesnatë"</string>
    <string name="Midnight" msgid="8176019203622191377">"Mesnatë"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="8689459651807876423">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="2302144714803345056">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="1532369154488982046">"Përzgjidhi të gjitha"</string>
    <string name="cut" msgid="2561199725874745819">"Pri"</string>
    <string name="copy" msgid="5472512047143665218">"Kopjo"</string>
    <string name="failed_to_copy_to_clipboard" msgid="725919885138539875">"Dështoi të kopjojë në kujtesën e fragmenteve"</string>
    <string name="paste" msgid="461843306215520225">"Ngjit"</string>
    <string name="paste_as_plain_text" msgid="7664800665823182587">"Ngjite si tekst të thjeshtë"</string>
    <string name="replace" msgid="7842675434546657444">"Zëvendëso…"</string>
    <string name="delete" msgid="1514113991712129054">"Fshi"</string>
    <string name="copyUrl" msgid="6229645005987260230">"Kopjo URL-në"</string>
    <string name="selectTextMode" msgid="3225108910999318778">"Përzgjidh tekstin"</string>
    <string name="undo" msgid="3175318090002654673">"Zhbëj"</string>
    <string name="redo" msgid="7231448494008532233">"Ribëj"</string>
    <string name="autofill" msgid="511224882647795296">"Plotësim automatik"</string>
    <string name="textSelectionCABTitle" msgid="5151441579532476940">"Përzgjedhja e tekstit"</string>
    <string name="addToDictionary" msgid="8041821113480950096">"Shto në fjalor"</string>
    <string name="deleteText" msgid="4200807474529938112">"Fshi"</string>
    <string name="inputMethod" msgid="1784759500516314751">"Metoda e hyrjes"</string>
    <string name="editTextMenuTitle" msgid="857666911134482176">"Veprimet e tekstit"</string>
    <string name="email" msgid="2503484245190492693">"Dërgo mail"</string>
    <string name="email_desc" msgid="8291893932252173537">"Dërgo email tek adresa e zgjedhur"</string>
    <string name="dial" msgid="4954567785798679706">"Telefono"</string>
    <string name="dial_desc" msgid="3072967472129276617">"Telefono në numrin e zgjedhur të telefonit"</string>
    <string name="map" msgid="6865483125449986339">"Hap hartën"</string>
    <string name="map_desc" msgid="1068169741300922557">"Gjej adresën e zgjedhur"</string>
    <string name="browse" msgid="8692753594669717779">"Hap"</string>
    <string name="browse_desc" msgid="5328523986921597700">"Hap URL-në e zgjedhur"</string>
    <string name="sms" msgid="3976991545867187342">"Dërgo mesazh"</string>
    <string name="sms_desc" msgid="997349906607675955">"Dërgo mesazh te numri i zgjedhur i telefonit"</string>
    <string name="add_contact" msgid="7404694650594333573">"Shto"</string>
    <string name="add_contact_desc" msgid="6419581556288775911">"Shto te kontaktet"</string>
    <string name="view_calendar" msgid="4274396845124626977">"Shiko"</string>
    <string name="view_calendar_desc" msgid="1739770773927245564">"Shiko kohën e zgjedhur në kalendar"</string>
    <string name="add_calendar_event" msgid="5564364269553091740">"Planifiko"</string>
    <string name="add_calendar_event_desc" msgid="5827530672900331107">"Planifiko ngjarjen për kohën e zgjedhur"</string>
    <string name="view_flight" msgid="2042802613849690108">"Monitoro"</string>
    <string name="view_flight_desc" msgid="2802812586218764790">"Monitoro fluturimin e zgjedhur"</string>
    <string name="translate" msgid="1416909787202727524">"Përkthe"</string>
    <string name="translate_desc" msgid="4096225388385338322">"Përkthe tekstin e zgjedhur"</string>
    <string name="define" msgid="5214255850068764195">"Përkufizo"</string>
    <string name="define_desc" msgid="6916651934713282645">"Përkufizo tekstin e zgjedhur"</string>
    <string name="low_internal_storage_view_title" msgid="9024241779284783414">"Hapësira ruajtëse po mbaron"</string>
    <string name="low_internal_storage_view_text" msgid="8172166728369697835">"Disa funksione të sistemit mund të mos punojnë"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="7368968163411251788">"Nuk ka hapësirë të mjaftueshme ruajtjeje për sistemin. Sigurohu që të kesh 250 MB hapësirë të lirë dhe pastaj të rifillosh."</string>
    <string name="app_running_notification_title" msgid="8985999749231486569">"<xliff:g id="APP_NAME">%1$s</xliff:g> është në punë."</string>
    <string name="app_running_notification_text" msgid="5120815883400228566">"Trokit për më shumë informacione ose për të ndaluar aplikacionin."</string>
    <string name="ok" msgid="2646370155170753815">"Në rregull"</string>
    <string name="cancel" msgid="6908697720451760115">"Anulo"</string>
    <string name="yes" msgid="9069828999585032361">"Në rregull"</string>
    <string name="no" msgid="5122037903299899715">"Anulo"</string>
    <string name="dialog_alert_title" msgid="651856561974090712">"Kujdes!"</string>
    <string name="loading" msgid="3138021523725055037">"Po ngarkohet..."</string>
    <string name="capital_on" msgid="2770685323900821829">"Aktivizuar"</string>
    <string name="capital_off" msgid="7443704171014626777">"Çaktivizuar"</string>
    <string name="whichApplication" msgid="5432266899591255759">"Përfundo veprimin duke përdorur"</string>
    <string name="whichApplicationNamed" msgid="6969946041713975681">"Përfundo veprimin duke përdorur %1$s"</string>
    <string name="whichApplicationLabel" msgid="7852182961472531728">"Përfundo veprimin"</string>
    <string name="whichViewApplication" msgid="5733194231473132945">"Hap me"</string>
    <string name="whichViewApplicationNamed" msgid="415164730629690105">"Hap me %1$s"</string>
    <string name="whichViewApplicationLabel" msgid="7367556735684742409">"Hap"</string>
    <string name="whichOpenHostLinksWith" msgid="7645631470199397485">"Hapi lidhjet e <xliff:g id="HOST">%1$s</xliff:g> me"</string>
    <string name="whichOpenLinksWith" msgid="1120936181362907258">"Hapi lidhjet me"</string>
    <string name="whichOpenLinksWithApp" msgid="6917864367861910086">"Hapi lidhjet me <xliff:g id="APPLICATION">%1$s</xliff:g>"</string>
    <string name="whichOpenHostLinksWithApp" msgid="2401668560768463004">"Hapi lidhjet e <xliff:g id="HOST">%1$s</xliff:g> me <xliff:g id="APPLICATION">%2$s</xliff:g>"</string>
    <string name="whichGiveAccessToApplicationLabel" msgid="7805857277166106236">"Jep qasje"</string>
    <string name="whichEditApplication" msgid="6191568491456092812">"Redakto me"</string>
    <string name="whichEditApplicationNamed" msgid="8096494987978521514">"Redakto me %1$s"</string>
    <string name="whichEditApplicationLabel" msgid="1463288652070140285">"Redakto"</string>
    <string name="whichSendApplication" msgid="4143847974460792029">"Ndaj"</string>
    <string name="whichSendApplicationNamed" msgid="4470386782693183461">"Shpërnda publikisht me %1$s"</string>
    <string name="whichSendApplicationLabel" msgid="7467813004769188515">"Ndaj"</string>
    <string name="whichSendToApplication" msgid="77101541959464018">"Dërgo me"</string>
    <string name="whichSendToApplicationNamed" msgid="3385686512014670003">"Dërgo me %1$s"</string>
    <string name="whichSendToApplicationLabel" msgid="3543240188816513303">"Dërgo"</string>
    <string name="whichHomeApplication" msgid="8276350727038396616">"Përzgjidh një aplikacion nga ekrani bazë"</string>
    <string name="whichHomeApplicationNamed" msgid="5855990024847433794">"Përdore %1$s si faqe bazë"</string>
    <string name="whichHomeApplicationLabel" msgid="8907334282202933959">"Regjistro imazhin"</string>
    <string name="whichImageCaptureApplication" msgid="2737413019463215284">"Regjistro imazhin me"</string>
    <string name="whichImageCaptureApplicationNamed" msgid="8820702441847612202">"Regjistro imazhin me %1$s"</string>
    <string name="whichImageCaptureApplicationLabel" msgid="6505433734824988277">"Regjistro imazhin"</string>
    <string name="alwaysUse" msgid="3153558199076112903">"Përdore si parametër të paracaktuar për këtë veprim."</string>
    <string name="use_a_different_app" msgid="4987790276170972776">"Përdor një aplikacion tjetër"</string>
    <string name="clearDefaultHintMsg" msgid="1325866337702524936">"Pastro zgjedhjet e paracaktuara në \"Cilësimet e sistemit\" &gt; \"Aplikacionet\" &gt; \"Të shkarkuara\"."</string>
    <string name="chooseActivity" msgid="8563390197659779956">"Zgjidh një veprim"</string>
    <string name="chooseUsbActivity" msgid="2096269989990986612">"Zgjidh një aplikacion për pajisjen \"USB\""</string>
    <string name="noApplications" msgid="1186909265235544019">"Asnjë aplikacion nuk mund ta kryejë këtë veprim."</string>
    <string name="aerr_application" msgid="4090916809370389109">"<xliff:g id="APPLICATION">%1$s</xliff:g> ka ndaluar"</string>
    <string name="aerr_process" msgid="4268018696970966407">"<xliff:g id="PROCESS">%1$s</xliff:g> ka ndaluar"</string>
    <string name="aerr_application_repeated" msgid="7804378743218496566">"<xliff:g id="APPLICATION">%1$s</xliff:g> vazhdon të ndalojë"</string>
    <string name="aerr_process_repeated" msgid="1153152413537954974">"<xliff:g id="PROCESS">%1$s</xliff:g> vazhdon të ndalojë"</string>
    <string name="aerr_restart" msgid="2789618625210505419">"Hap përsëri aplikacionin"</string>
    <string name="aerr_report" msgid="3095644466849299308">"Dërgo koment"</string>
    <string name="aerr_close" msgid="3398336821267021852">"Mbyll"</string>
    <string name="aerr_mute" msgid="2304972923480211376">"Vendose në heshtje deri kur të riniset pajisja"</string>
    <string name="aerr_wait" msgid="3198677780474548217">"Prit!"</string>
    <string name="aerr_close_app" msgid="8318883106083050970">"Mbyll aplikacionin"</string>
    <string name="anr_title" msgid="7290329487067300120"></string>
    <string name="anr_activity_application" msgid="8121716632960340680">"<xliff:g id="APPLICATION">%2$s</xliff:g> nuk përgjigjet"</string>
    <string name="anr_activity_process" msgid="3477362583767128667">"<xliff:g id="ACTIVITY">%1$s</xliff:g> nuk përgjigjet"</string>
    <string name="anr_application_process" msgid="4978772139461676184">"<xliff:g id="APPLICATION">%1$s</xliff:g> nuk përgjigjet"</string>
    <string name="anr_process" msgid="1664277165911816067">"Përpunimi i <xliff:g id="PROCESS">%1$s</xliff:g> nuk përgjigjet"</string>
    <string name="force_close" msgid="9035203496368973803">"Në rregull"</string>
    <string name="report" msgid="2149194372340349521">"Raporto"</string>
    <string name="wait" msgid="7765985809494033348">"Prit!"</string>
    <string name="webpage_unresponsive" msgid="7850879412195273433">"Faqja nuk reagon.\n\nDëshiron ta mbyllësh?"</string>
    <string name="launch_warning_title" msgid="6725456009564953595">"Aplikacioni u ridrejtua"</string>
    <string name="launch_warning_replace" msgid="3073392976283203402">"<xliff:g id="APP_NAME">%1$s</xliff:g> është tani në punë."</string>
    <string name="launch_warning_original" msgid="3332206576800169626">"<xliff:g id="APP_NAME">%1$s</xliff:g> ishte hapur fillimisht."</string>
    <string name="screen_compat_mode_scale" msgid="8627359598437527726">"Shkalla"</string>
    <string name="screen_compat_mode_show" msgid="5080361367584709857">"Shfaq gjithnjë"</string>
    <string name="screen_compat_mode_hint" msgid="4032272159093750908">"Aktivizoje sërish këtë te \"Cilësimet e sistemit\" &gt; \"Aplikacionet\" &gt; \"Të shkarkuara\"."</string>
    <string name="unsupported_display_size_message" msgid="7265211375269394699">"<xliff:g id="APP_NAME">%1$s</xliff:g> nuk mbështet cilësimin aktual të madhësisë së ekranit dhe mund të shfaqë sjellje të papritura."</string>
    <string name="unsupported_display_size_show" msgid="980129850974919375">"Shfaq gjithmonë"</string>
    <string name="unsupported_compile_sdk_message" msgid="7326293500707890537">"<xliff:g id="APP_NAME">%1$s</xliff:g> është ndërtuar për një version të papërputhshëm të sistemit operativ Android dhe mund të shfaqë sjellje të papritura. Mund të ofrohet një version i përditësuar i aplikacionit."</string>
    <string name="unsupported_compile_sdk_show" msgid="1601210057960312248">"Shfaq gjithnjë"</string>
    <string name="unsupported_compile_sdk_check_update" msgid="1103639989147664456">"Kontrollo për përditësim"</string>
    <string name="smv_application" msgid="3775183542777792638">"Aplikacioni <xliff:g id="APPLICATION">%1$s</xliff:g> (procesi <xliff:g id="PROCESS">%2$s</xliff:g>) ka shkelur politikën e tij të vetë-imponuar \"Modaliteti i ashpër\" (StrictMode)."</string>
    <string name="smv_process" msgid="1398801497130695446">"Procesi <xliff:g id="PROCESS">%1$s</xliff:g> ka shkelur politikën e tij të vetë-imponuar \"Modaliteti i rreptë\" (StrictMode)"</string>
    <string name="android_upgrading_title" product="default" msgid="7279077384220829683">"Telefoni po përditësohet…"</string>
    <string name="android_upgrading_title" product="tablet" msgid="4268417249079938805">"Tableti po përditësohet…"</string>
    <string name="android_upgrading_title" product="device" msgid="6774767702998149762">"Pajisja po përditësohet…"</string>
    <string name="android_start_title" product="default" msgid="4036708252778757652">"Telefoni po niset…"</string>
    <string name="android_start_title" product="automotive" msgid="7917984412828168079">"\"Androidi\" po fillon…"</string>
    <string name="android_start_title" product="tablet" msgid="4429767260263190344">"Tableti po niset…"</string>
    <string name="android_start_title" product="device" msgid="6967413819673299309">"Pajisja po niset…"</string>
    <string name="android_upgrading_fstrim" msgid="3259087575528515329">"Po përshtat ruajtjen."</string>
    <string name="android_upgrading_notification_title" product="default" msgid="3509927005342279257">"Po përfundon përditësimi i sistemit…"</string>
    <string name="app_upgrading_toast" msgid="1016267296049455585">"<xliff:g id="APPLICATION">%1$s</xliff:g> po përmirësohet…"</string>
    <string name="android_upgrading_apk" msgid="1339564803894466737">"Po përshtat aplikacionin <xliff:g id="NUMBER_0">%1$d</xliff:g> nga gjithsej <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_preparing_apk" msgid="589736917792300956">"Po përgatit <xliff:g id="APPNAME">%1$s</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="6206161195076057075">"Aplikacionet e fillimit."</string>
    <string name="android_upgrading_complete" msgid="409800058018374746">"Po përfundon nisjen."</string>
    <string name="heavy_weight_notification" msgid="8382784283600329576">"<xliff:g id="APP">%1$s</xliff:g> është në punë"</string>
    <string name="heavy_weight_notification_detail" msgid="6802247239468404078">"Trokit për t\'u kthyer te loja"</string>
    <string name="heavy_weight_switcher_title" msgid="3861984210040100886">"Zgjidh një lojë"</string>
    <string name="heavy_weight_switcher_text" msgid="6814316627367160126">"Për një cilësi më të mirë funksionimi, vetëm një nga këto lojëra mund të hapet në të njëjtën kohë."</string>
    <string name="old_app_action" msgid="725331621042848590">"Kthehu prapa te <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_action" msgid="547772182913269801">"Hap <xliff:g id="NEW_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1958903080400806644">"<xliff:g id="OLD_APP">%1$s</xliff:g> do të mbyllet pa u ruajtur"</string>
    <string name="dump_heap_notification" msgid="5316644945404825032">"<xliff:g id="PROC">%1$s</xliff:g> e ka kaluar kufirin e memories"</string>
    <string name="dump_heap_ready_notification" msgid="2302452262927390268">"Stiva e skedarëve fiktivë të <xliff:g id="PROC">%1$s</xliff:g> është gati"</string>
    <string name="dump_heap_notification_detail" msgid="8431586843001054050">"Stiva e skedarëve fiktivë është mbledhur. Trokit për t\'i ndarë."</string>
    <string name="dump_heap_title" msgid="4367128917229233901">"Të ndahet stiva e skedarëve fiktivë?"</string>
    <string name="dump_heap_text" msgid="1692649033835719336">"Procesi <xliff:g id="PROC">%1$s</xliff:g> ka kaluar kufirin e tij të memories prej <xliff:g id="SIZE">%2$s</xliff:g>. Ke një stivë të skedarësh fiktivë që mund ta ndash me zhvilluesin e tij. Ki kujdes pasi kjo stivë skedarësh fiktivë mund të përmbajë çdo informacion personal ku ka qasje aplikacioni."</string>
    <string name="dump_heap_system_text" msgid="6805155514925350849">"Procesi <xliff:g id="PROC">%1$s</xliff:g> e ka kaluar kufirin e tij të memories prej <xliff:g id="SIZE">%2$s</xliff:g>. Ke një stivë skedarësh fiktivë që mund ta ndash. Ki kujdes pasi kjo stivë skedarësh fiktivë mund të përmbajë çdo informacion personal delikat ku ka qasje procesi dhe mund të përfshijë gjërat që ke shkruar ti."</string>
    <string name="dump_heap_ready_text" msgid="5849618132123045516">"Ke një stivë skedarësh fiktivë të procesit <xliff:g id="PROC">%1$s</xliff:g> që mund ta ndash. Ki kujdes pasi kjo stivë skedarësh fiktivë mund të përmbajë çdo informacion personal delikat ku ka qasje procesi dhe mund të përfshijë gjërat që ke shkruar ti."</string>
    <string name="sendText" msgid="493003724401350724">"Zgjidh një veprim për tekstin"</string>
    <string name="volume_ringtone" msgid="134784084629229029">"Volumi i ziles"</string>
    <string name="volume_music" msgid="7727274216734955095">"Volumi i medias"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="2614142915948898228">"Luajtje përmes \"bluetooth-it\""</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="1514829655029062233">"Zilja \"në heshjte\" u caktua"</string>
    <string name="volume_call" msgid="7625321655265747433">"Volumi i telefonatës"</string>
    <string name="volume_bluetooth_call" msgid="2930204618610115061">"Volumi i telefonatës përmes \"bluetooth-it\""</string>
    <string name="volume_alarm" msgid="4486241060751798448">"Volumi i alarmit"</string>
    <string name="volume_notification" msgid="6864412249031660057">"Volumi i njoftimit"</string>
    <string name="volume_unknown" msgid="4041914008166576293">"Volumi"</string>
    <string name="volume_icon_description_bluetooth" msgid="7540388479345558400">"Volumi i \"bluetooth-it\""</string>
    <string name="volume_icon_description_ringer" msgid="2187800636867423459">"Volumi i ziles"</string>
    <string name="volume_icon_description_incall" msgid="4491255105381227919">"Volumi i telefonatës"</string>
    <string name="volume_icon_description_media" msgid="4997633254078171233">"Volumi i medias"</string>
    <string name="volume_icon_description_notification" msgid="579091344110747279">"Volumi i njoftimeve"</string>
    <string name="ringtone_default" msgid="9118299121288174597">"Zile e paracaktuar."</string>
    <string name="ringtone_default_with_actual" msgid="2709686194556159773">"I parazgjedhur (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="397111123930141876">"Asnjë"</string>
    <string name="ringtone_picker_title" msgid="667342618626068253">"Zilet"</string>
    <string name="ringtone_picker_title_alarm" msgid="7438934548339024767">"Tingujt e alarmeve"</string>
    <string name="ringtone_picker_title_notification" msgid="6387191794719608122">"Tingujt e njoftimeve"</string>
    <string name="ringtone_unknown" msgid="5059495249862816475">"E panjohur"</string>
    <string name="wifi_cannot_connect_with_randomized_mac_title" msgid="3638054829636549621">"Nuk mund të lidhet me <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_cannot_connect_with_randomized_mac_message" msgid="1660164954255520914">"Trokit për të ndryshuar cilësimet e privatësisë dhe provo përsëri"</string>
    <string name="wifi_disable_mac_randomization_dialog_title" msgid="2850303108790975442">"Do ta ndryshosh cilësimin e privatësisë?"</string>
    <string name="wifi_disable_mac_randomization_dialog_message" msgid="2434334967976496565">"<xliff:g id="SSID_0">%1$s</xliff:g> mund të dëshirojë të lidhet duke përdorur adresën MAC të pajisjes sate, një identifikues unik. Kjo mund të lejojë monitorimin e vendndodhjes së pajisjes sate nga pajisjet në afërsi. \n\nNëse vazhdon, <xliff:g id="SSID_1">%1$s</xliff:g> do të ndryshojë cilësimin tënd të privatësisë dhe do të provojë të lidhet përsëri."</string>
    <string name="wifi_disable_mac_randomization_dialog_confirm_text" msgid="8206498512998282366">"Ndrysho cilësimin"</string>
    <string name="wifi_disable_mac_randomization_dialog_success" msgid="6654175395681450625">"Cilësimi u përditësua. Provo të lidhesh përsëri."</string>
    <string name="wifi_disable_mac_randomization_dialog_failure" msgid="7028090406806909137">"Cilësimi i privatësisë nuk mund të ndryshohet"</string>
    <string name="wifi_disable_mac_randomization_dialog_network_not_found" msgid="6829886686837356040">"Rrjeti nuk u gjet"</string>
    <plurals name="wifi_available" formatted="false" msgid="7209257945504714015">
      <item quantity="other">Rrjete Wi-Fi ofrohen për përdorim</item>
      <item quantity="one">Një rrjet Wi-Fi ofrohet për përdorim</item>
    </plurals>
    <plurals name="wifi_available_detailed" formatted="false" msgid="1104430011355500386">
      <item quantity="other">Rrjete të hapura Wi-Fi në përdorim</item>
      <item quantity="one">Rrjet i hapur Wi-Fi në përdorim</item>
    </plurals>
    <string name="wifi_available_title" msgid="722493260955778406">"Lidhu me rrjetin e hapur Wi‑Fi"</string>
    <string name="wifi_available_carrier_network_title" msgid="7740328884692643968">"Lidhu me rrjetin Wi‑Fi të operatorit"</string>
    <string name="wifi_available_title_connecting" msgid="5249247039230566878">"Po lidhet me rrjetin Wi‑Fi"</string>
    <string name="wifi_available_title_connected" msgid="5892203664604121475">"Lidhur me rrjetin e hapur Wi‑Fi"</string>
    <string name="wifi_available_title_failed_to_connect" msgid="5133141923288104331">"Nuk mund të lidhet me rrjetin Wi‑Fi"</string>
    <string name="wifi_available_content_failed_to_connect" msgid="3555247614042954032">"Trokit për të parë të gjitha rrjetet"</string>
    <string name="wifi_available_action_connect" msgid="924369499736631716">"Lidhu"</string>
    <string name="wifi_available_action_all_networks" msgid="7759049005868147147">"Të gjitha rrjetet"</string>
    <string name="wifi_suggestion_title" msgid="5041459385180298879">"Të lejohen rrjetet e sugjeruara Wi‑Fi?"</string>
    <string name="wifi_suggestion_content" msgid="477311057093517127">"Rrjet e sugjeruara të <xliff:g id="NAME">%s</xliff:g>. Pajisja mund të lidhet automatikisht."</string>
    <string name="wifi_suggestion_action_allow_app" msgid="6292456946562368121">"Lejo"</string>
    <string name="wifi_suggestion_action_disallow_app" msgid="5544497236277666556">"Jo, faleminderit"</string>
    <string name="wifi_wakeup_onboarding_title" msgid="2609831579583316922">"Wi‑Fi do të aktivizohet automatikisht"</string>
    <string name="wifi_wakeup_onboarding_subtext" msgid="6802089127390267217">"Kur ndodhesh pranë një rrjeti të ruajtur me cilësi të lartë"</string>
    <string name="wifi_wakeup_onboarding_action_disable" msgid="9093154721154555101">"Mos e aktivizo përsëri"</string>
    <string name="wifi_wakeup_enabled_title" msgid="7983113075476310532">"Wi‑Fi u aktivizua automatikisht"</string>
    <string name="wifi_wakeup_enabled_content" msgid="5672823591753088037">"Ndodhesh pranë një rrjeti të ruajtur: <xliff:g id="NETWORK_SSID">%1$s</xliff:g>"</string>
    <string name="wifi_available_sign_in" msgid="381054692557675237">"Identifikohu në rrjetin Wi-Fi"</string>
    <string name="network_available_sign_in" msgid="1520342291829283114">"Identifikohu në rrjet"</string>
    <!-- no translation found for network_available_sign_in_detailed (7520423801613396556) -->
    <skip />
    <string name="wifi_no_internet" msgid="1386911698276448061">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> nuk ka qasje në internet"</string>
    <string name="wifi_no_internet_detailed" msgid="634938444133558942">"Trokit për opsionet"</string>
    <string name="captive_portal_logged_in_detailed" msgid="3897392681039344376">"Lidhur"</string>
    <string name="network_partial_connectivity" msgid="4791024923851432291">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> ka lidhshmëri të kufizuar"</string>
    <string name="network_partial_connectivity_detailed" msgid="5741329444564575840">"Trokit për t\'u lidhur gjithsesi"</string>
    <string name="wifi_softap_config_change" msgid="9101613252632264297">"Ndryshimet në cilësimet e zonës së qasjes për internet"</string>
    <string name="wifi_softap_config_change_summary" msgid="3818290044234944123">"Brezi yt i zonës së qasjes për internet ka ndryshuar."</string>
    <string name="wifi_softap_config_change_detailed" msgid="2531736378103873579">"Kjo pajisje nuk e mbështet preferencën për vetëm 5 GHz. Përkundrazi, pajisja do të përdorë brezin 5 GHz nëse ka."</string>
    <string name="network_switch_metered" msgid="1531869544142283384">"Kaloi te <xliff:g id="NETWORK_TYPE">%1$s</xliff:g>"</string>
    <string name="network_switch_metered_detail" msgid="1358296010128405906">"Pajisja përdor <xliff:g id="NEW_NETWORK">%1$s</xliff:g> kur <xliff:g id="PREVIOUS_NETWORK">%2$s</xliff:g> nuk ka qasje në internet. Mund të zbatohen tarifa."</string>
    <string name="network_switch_metered_toast" msgid="501662047275723743">"Kaloi nga <xliff:g id="PREVIOUS_NETWORK">%1$s</xliff:g> te <xliff:g id="NEW_NETWORK">%2$s</xliff:g>"</string>
  <string-array name="network_switch_type_name">
    <item msgid="2255670471736226365">"të dhënat celulare"</item>
    <item msgid="5520925862115353992">"Wi-Fi"</item>
    <item msgid="1055487873974272842">"Bluetooth"</item>
    <item msgid="1616528372438698248">"Eternet"</item>
    <item msgid="9177085807664964627">"VPN"</item>
  </string-array>
    <string name="network_switch_type_name_unknown" msgid="3665696841646851068">"një lloj rrjeti i panjohur"</string>
    <string name="wifi_watchdog_network_disabled" msgid="588755196559781297">"Nuk mund të lidhej me Wi-Fi"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5469207538636315968">" ka një lidhje të dobët interneti."</string>
    <string name="wifi_connect_alert_title" msgid="2377999802455909057">"Të lejohet lidhja?"</string>
    <string name="wifi_connect_alert_message" msgid="169228218944976720">"Aplikacioni %1$s do të lidhet me rrjetin Wi-Fi %2$s"</string>
    <string name="wifi_connect_default_application" msgid="7577787709633050605">"Një aplikacion"</string>
    <string name="wifi_p2p_dialog_title" msgid="6334579064086920198">"Wi-Fi Direkt"</string>
    <string name="wifi_p2p_turnon_message" msgid="804818801818052402">"Fillo \"Wi-Fi Direkt\". Kjo do ta çaktivizojë klientin ose zonën e qasjes Wi-Fi."</string>
    <string name="wifi_p2p_failed_message" msgid="6296397512378755690">"Nuk mundi të fillonte \"Wi-Fi Direkt\"."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="9128862563403191596">"\"Wi-Fi Direkt\" është aktiv"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="5571179544720861510">"Trokit për cilësimet"</string>
    <string name="accept" msgid="5447154347815825107">"Prano"</string>
    <string name="decline" msgid="6490507610282145874">"Refuzo"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="355410493918793111">"Ftesa u dërgua"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="8082524320754820762">"Ftesë për t\'u lidhur"</string>
    <string name="wifi_p2p_from_message" msgid="8288949679353111893">"Nga:"</string>
    <string name="wifi_p2p_to_message" msgid="2841587668240064488">"Për:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="1020819021188731574">"Shkruaj PIN-in e kërkuar:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="3598694912050152976">"PIN-i:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="6006673840559201871">"Tableti do të shkëputet përkohësisht nga Wi-Fi gjatë kohës së lidhjes me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tv" msgid="1081550817886390524">"Televizori do të shkëputet përkohësisht nga Wi-Fi gjatë kohës së lidhjes me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="5357599796604438547">"Telefoni do të shkëputet përkohësisht nga Wi-Fi gjatë kohës së lidhjes me <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="select_character" msgid="3352797107930786979">"Fut karakterin"</string>
    <string name="sms_control_title" msgid="4748684259903148341">"Po dërgon mesazhe SMS"</string>
    <string name="sms_control_message" msgid="6574313876316388239">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; po dërgon një numër të lartë mesazhesh SMS. Do ta lejosh aplikacionin të vazhdojë të dërgojë mesazhe?"</string>
    <string name="sms_control_yes" msgid="4858845109269524622">"Lejo"</string>
    <string name="sms_control_no" msgid="4845717880040355570">"Moho"</string>
    <string name="sms_short_code_confirm_message" msgid="1385416688897538724">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; dëshiron të dërgojë një mesazh në &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="2723725738333388351">"Kjo "<b>"mund të shkaktojë tarifa shtesë"</b>" në llogarinë tënde celulare."</string>
    <string name="sms_premium_short_code_details" msgid="1400296309866638111"><b>"Kjo do të shkaktojë tarifa shtesë në llogarinë tënde celulare."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="920477594325526691">"Dërgo"</string>
    <string name="sms_short_code_confirm_deny" msgid="1356917469323768230">"Anulo"</string>
    <string name="sms_short_code_remember_choice" msgid="1374526438647744862">"Kujto zgjedhjen time"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="2620984439143080410">"Këtë mund ta ndryshosh më vonë te \"Cilësimet\" &gt; \"Aplikacionet\""</string>
    <string name="sms_short_code_confirm_always_allow" msgid="2223014893129755950">"Lejo gjithmonë"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="2688828813521652079">"Mos lejo asnjëherë"</string>
    <string name="sim_removed_title" msgid="5387212933992546283">"Karta SIM u hoq"</string>
    <string name="sim_removed_message" msgid="9051174064474904617">"Rrjeti celular nuk do të mundësohet derisa ta rinisësh pajisjen me një kartë të vlefshme SIM në të."</string>
    <string name="sim_done_button" msgid="6464250841528410598">"U krye!"</string>
    <string name="sim_added_title" msgid="7930779986759414595">"Karta SIM u shtua"</string>
    <string name="sim_added_message" msgid="6602906609509958680">"Rinise pajisjen për të pasur qasje në rrjetin celular."</string>
    <string name="sim_restart_button" msgid="8481803851341190038">"Rifillo"</string>
    <string name="install_carrier_app_notification_title" msgid="5712723402213090102">"Aktivizo shërbimin celular"</string>
    <string name="install_carrier_app_notification_text" msgid="2781317581274192728">"Shkarko aplikacionin e operatorit celular për të aktivizuar kartën e re SIM"</string>
    <string name="install_carrier_app_notification_text_app_name" msgid="4086877327264106484">"Shkarko aplikacionin <xliff:g id="APP_NAME">%1$s</xliff:g> për të aktivizuar kartën tënde të re SIM"</string>
    <string name="install_carrier_app_notification_button" msgid="6257740533102594290">"Shkarko aplikacionin"</string>
    <string name="carrier_app_notification_title" msgid="5815477368072060250">"Është futur kartë e re SIM"</string>
    <string name="carrier_app_notification_text" msgid="6567057546341958637">"Trokit për ta konfiguruar"</string>
    <string name="time_picker_dialog_title" msgid="9053376764985220821">"Cakto kohën"</string>
    <string name="date_picker_dialog_title" msgid="5030520449243071926">"Vendos datën"</string>
    <string name="date_time_set" msgid="4603445265164486816">"Cakto"</string>
    <string name="date_time_done" msgid="8363155889402873463">"U krye!"</string>
    <string name="perms_new_perm_prefix" msgid="6984556020395757087"><font size="12" fgcolor="#ff33b5e5">"E RE: "</font></string>
    <string name="perms_description_app" msgid="2747752389870161996">"Ofruar nga <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="5729199278862516390">"Nuk kërkohen leje"</string>
    <string name="perm_costs_money" msgid="749054595022779685">"kjo mund të të kushtojë para"</string>
    <string name="dlg_ok" msgid="5103447663504839312">"Në rregull"</string>
    <string name="usb_charging_notification_title" msgid="1674124518282666955">"Kjo pajisje po karikohet nëpërmjet USB-së"</string>
    <string name="usb_supplying_notification_title" msgid="5378546632408101811">"Pajisja e lidhur po karikohet nëpërmjet USB-së"</string>
    <string name="usb_mtp_notification_title" msgid="1065989144124499810">"Transferimi i skedarëve nëpërmjet USB-së u aktivizua"</string>
    <string name="usb_ptp_notification_title" msgid="5043437571863443281">"PTP nëpërmjet USB-së u aktivizua"</string>
    <string name="usb_tether_notification_title" msgid="8828527870612663771">"Ndarja e internetit nëpërmjet USB-së u aktivizua"</string>
    <string name="usb_midi_notification_title" msgid="7404506788950595557">"MIDI nëpërmjet USB-së u aktivizua"</string>
    <string name="usb_accessory_notification_title" msgid="1385394660861956980">"Aksesori i USB-së u lidh"</string>
    <string name="usb_notification_message" msgid="4715163067192110676">"Trokit për më shumë opsione."</string>
    <string name="usb_power_notification_message" msgid="7284765627437897702">"Pajisja e lidhur po karikohet. Trokit për opsione të tjera."</string>
    <string name="usb_unsupported_audio_accessory_title" msgid="2335775548086533065">"U zbulua aksesor i audios analoge"</string>
    <string name="usb_unsupported_audio_accessory_message" msgid="1300168007129796621">"Pajisja e bashkuar nuk është e pajtueshme me këtë telefon. Trokit për të mësuar më shumë."</string>
    <string name="adb_active_notification_title" msgid="408390247354560331">"Korrigjuesi i USB-së është i lidhur"</string>
    <string name="adb_active_notification_message" msgid="5617264033476778211">"Trokit për të çaktivizuar korrigjimin e USB-së"</string>
    <string name="adb_active_notification_message" product="tv" msgid="6624498401272780855">"Përzgjidhe për të çaktivizuar korrigjimin e gabimeve të USB-së"</string>
    <string name="test_harness_mode_notification_title" msgid="2282785860014142511">"Modaliteti i lidhjes së testimit është aktivizuar"</string>
    <string name="test_harness_mode_notification_message" msgid="3039123743127958420">"Kryej një rivendosje në cilësimet e fabrikës për të çaktivizuar \"Modalitetin e lidhjes së testimit\"."</string>
    <string name="usb_contaminant_detected_title" msgid="4359048603069159678">"Lëngje ose papastërti në portën e USB-së"</string>
    <string name="usb_contaminant_detected_message" msgid="7346100585390795743">"Porta e USB-së është çaktivizuar automatikisht. Trokit për të mësuar më shumë."</string>
    <string name="usb_contaminant_not_detected_title" msgid="2651167729563264053">"Në rregulloj për përdorimin e portës USB"</string>
    <string name="usb_contaminant_not_detected_message" msgid="892863190942660462">"Telefoni nuk i dallon më lëngjet apo papastërtitë."</string>
    <string name="taking_remote_bugreport_notification_title" msgid="1582531382166919850">"Po merret raporti i defekteve në kod…"</string>
    <string name="share_remote_bugreport_notification_title" msgid="6708897723753334999">"Të ndahet raporti i defektit në kod?"</string>
    <string name="sharing_remote_bugreport_notification_title" msgid="3077385149217638550">"Po ndan raportin e defekteve në kod..."</string>
    <string name="share_remote_bugreport_notification_message_finished" msgid="7325635795739260135">"Administratori 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_action" msgid="7630880678785123682">"SHPËRNDAJ"</string>
    <string name="decline_remote_bugreport_action" msgid="4040894777519784346">"REFUZO"</string>
    <string name="select_input_method" msgid="3971267998568587025">"Zgjidh metodën e hyrjes"</string>
    <string name="show_ime" msgid="6406112007347443383">"Mbaje në ekran ndërsa tastiera fizike është aktive"</string>
    <string name="hardware" msgid="1800597768237606953">"Shfaq tastierën virtuale"</string>
    <string name="select_keyboard_layout_notification_title" msgid="4427643867639774118">"Konfiguro tastierën fizike"</string>
    <string name="select_keyboard_layout_notification_message" msgid="8835158247369158154">"Trokit për të zgjedhur gjuhën dhe strukturën"</string>
    <string name="fast_scroll_alphabet" msgid="8854435958703888376">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="2529539945421557329">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="alert_windows_notification_channel_group_name" msgid="6063891141815714246">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="alert_windows_notification_channel_name" msgid="3437528564303192620">"<xliff:g id="NAME">%s</xliff:g> afishohet mbi aplikacionet e tjera"</string>
    <string name="alert_windows_notification_title" msgid="6331662751095228536">"<xliff:g id="NAME">%s</xliff:g> shfaqet mbi apl. e tjera"</string>
    <string name="alert_windows_notification_message" msgid="6538171456970725333">"Nëse nuk dëshiron që <xliff:g id="NAME">%s</xliff:g> ta përdorë këtë funksion, trokit për të hapur cilësimet dhe për ta çaktivizuar."</string>
    <string name="alert_windows_notification_turn_off_action" msgid="7805857234839123780">"Çaktivizo"</string>
    <string name="ext_media_checking_notification_title" msgid="8299199995416510094">"<xliff:g id="NAME">%s</xliff:g> po kontrollohet…"</string>
    <string name="ext_media_checking_notification_message" msgid="2231566971425375542">"Përmbajtja aktuale po rishikohet"</string>
    <string name="ext_media_new_notification_title" msgid="3517407571407687677">"<xliff:g id="NAME">%s</xliff:g> e re"</string>
    <string name="ext_media_new_notification_message" msgid="6095403121990786986">"Trokit për ta konfiguruar"</string>
    <string name="ext_media_ready_notification_message" msgid="777258143284919261">"Për transferimin e fotografive dhe skedarëve të tjerë"</string>
    <string name="ext_media_unmountable_notification_title" msgid="4895444667278979910">"Problem me <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_message" msgid="3256290114063126205">"Trokit për ta rregulluar"</string>
    <string name="ext_media_unmountable_notification_message" product="tv" msgid="3003611129979934633">"<xliff:g id="NAME">%s</xliff:g> është dëmtuar. Zgjidh për ta rregulluar."</string>
    <string name="ext_media_unsupported_notification_title" msgid="4358280700537030333">"<xliff:g id="NAME">%s</xliff:g> nuk mbështetet"</string>
    <string name="ext_media_unsupported_notification_message" msgid="917738524888367560">"Kjo pajisje nuk e mbështet këtë <xliff:g id="NAME">%s</xliff:g>. Trokit për ta konfiguruar në një format të mbështetur."</string>
    <string name="ext_media_unsupported_notification_message" product="tv" msgid="7744945987775645685">"Kjo pajisje nuk e mbështet këtë <xliff:g id="NAME">%s</xliff:g>. Përzgjidhe për ta konfiguruar në një format të mbështetur."</string>
    <string name="ext_media_badremoval_notification_title" msgid="4114625551266196872">"<xliff:g id="NAME">%s</xliff:g> u hoq papritur"</string>
    <string name="ext_media_badremoval_notification_message" msgid="1986514704499809244">"Nxirr median para se ta heqësh për të shmangur humbjen e përmbajtjes"</string>
    <string name="ext_media_nomedia_notification_title" msgid="742671636376975890">"<xliff:g id="NAME">%s</xliff:g> u hoq"</string>
    <string name="ext_media_nomedia_notification_message" msgid="2832724384636625852">"Disa funksionalitete mund të mos funksionojnë si duhet. Fut një hapësirë ruajtëse të re."</string>
    <string name="ext_media_unmounting_notification_title" msgid="4147986383917892162">"<xliff:g id="NAME">%s</xliff:g> po nxirret"</string>
    <string name="ext_media_unmounting_notification_message" msgid="5717036261538754203">"Mos e hiq"</string>
    <string name="ext_media_init_action" msgid="2312974060585056709">"Konfiguro"</string>
    <string name="ext_media_unmount_action" msgid="966992232088442745">"Nxirr"</string>
    <string name="ext_media_browse_action" msgid="344865351947079139">"Eksploro"</string>
    <string name="ext_media_seamless_action" msgid="8837030226009268080">"Ndrysho daljen"</string>
    <string name="ext_media_missing_title" msgid="3209472091220515046">"<xliff:g id="NAME">%s</xliff:g> mungon"</string>
    <string name="ext_media_missing_message" msgid="4408988706227922909">"Fut përsëri pajisjen"</string>
    <string name="ext_media_move_specific_title" msgid="8492118544775964250">"Po zhvendos <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_title" msgid="2682741525619033637">"Po zhvendos të dhënat"</string>
    <string name="ext_media_move_success_title" msgid="4901763082647316767">"Transferimi i përmbajtjes u krye"</string>
    <string name="ext_media_move_success_message" msgid="9159542002276982979">"Përmbajtja u zhvendos te <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="3184577479181333665">"Përmbajtja s\'mund të zhvendosej"</string>
    <string name="ext_media_move_failure_message" msgid="4197306718121869335">"Provo ta zhvendosësh përsëri përmbajtjen"</string>
    <string name="ext_media_status_removed" msgid="241223931135751691">"E hequr"</string>
    <string name="ext_media_status_unmounted" msgid="8145812017295835941">"E nxjerrë"</string>
    <string name="ext_media_status_checking" msgid="159013362442090347">"Po kontrollon..."</string>
    <string name="ext_media_status_mounted" msgid="3459448555811203459">"Gati"</string>
    <string name="ext_media_status_mounted_ro" msgid="1974809199760086956">"Vetëm për lexim"</string>
    <string name="ext_media_status_bad_removal" msgid="508448566481406245">"U hoq në mënyrë të sigurt"</string>
    <string name="ext_media_status_unmountable" msgid="7043574843541087748">"E dëmtuar"</string>
    <string name="ext_media_status_unsupported" msgid="5460509911660539317">"Nuk mbështetet"</string>
    <string name="ext_media_status_ejecting" msgid="7532403368044013797">"Po nxjerr…"</string>
    <string name="ext_media_status_formatting" msgid="774148701503179906">"Po formaton…"</string>
    <string name="ext_media_status_missing" msgid="6520746443048867314">"Nuk është futur"</string>
    <string name="activity_list_empty" msgid="4219430010716034252">"Nuk u gjet asnjë aktivitet që përputhet."</string>
    <string name="permlab_route_media_output" msgid="8048124531439513118">"kalo daljet e përmbajtjes audio-vizuale"</string>
    <string name="permdesc_route_media_output" msgid="1759683269387729675">"Lejon një aplikacion të kalojë daljet mediatike në pajisje të tjera të jashtme."</string>
    <string name="permlab_readInstallSessions" msgid="7279049337895583621">"lexo sesionet e instalimit"</string>
    <string name="permdesc_readInstallSessions" msgid="4012608316610763473">"Lejon një aplikacion të lexojë sesionet e instalimit. Kjo e lejon atë të shohë detaje rreth instalimeve të paketave aktive."</string>
    <string name="permlab_requestInstallPackages" msgid="7600020863445351154">"kërko paketat e instalimit"</string>
    <string name="permdesc_requestInstallPackages" msgid="3969369278325313067">"Lejon që një aplikacion të kërkojë instalimin e paketave."</string>
    <string name="permlab_requestDeletePackages" msgid="2541172829260106795">"kërko fshirjen e paketave"</string>
    <string name="permdesc_requestDeletePackages" msgid="6133633516423860381">"Lejon që një aplikacion të kërkojë fshirjen e paketave."</string>
    <string name="permlab_requestIgnoreBatteryOptimizations" msgid="7646611326036631439">"kërko të shpërfillësh optimizimet e baterisë"</string>
    <string name="permdesc_requestIgnoreBatteryOptimizations" msgid="634260656917874356">"Lejon që një aplikacion të kërkojë leje për të shpërfillur optimizimet e baterisë për atë aplikacion."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1842872462124648678">"Trokit dy herë për të kontrolluar zmadhimin"</string>
    <string name="gadget_host_error_inflating" msgid="2449961590495198720">"Nuk mundi të shtonte miniaplikacion."</string>
    <string name="ime_action_go" msgid="5536744546326495436">"Shko"</string>
    <string name="ime_action_search" msgid="4501435960587287668">"Kërko"</string>
    <string name="ime_action_send" msgid="8456843745664334138">"Dërgo"</string>
    <string name="ime_action_next" msgid="4169702997635728543">"Përpara"</string>
    <string name="ime_action_done" msgid="6299921014822891569">"U krye!"</string>
    <string name="ime_action_previous" msgid="6548799326860401611">"I mëparshëm"</string>
    <string name="ime_action_default" msgid="8265027027659800121">"Ekzekuto"</string>
    <string name="dial_number_using" msgid="6060769078933953531">"Telefono numrin\nduke përdorur <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="6200708808003692594">"Krijo kontakt\nduke përdorur <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="5365733888842570481">"Aplikacioni i mëposhtëm ose aplikacione të tjera kërkojnë leje për qasje në llogarinë tënde, tani dhe në të ardhmen."</string>
    <string name="grant_credentials_permission_message_footer" msgid="1886710210516246461">"Dëshiron ta lejosh këtë kërkesë?"</string>
    <string name="grant_permissions_header_text" msgid="3420736827804657201">"Kërkesë për qasje"</string>
    <string name="allow" msgid="6195617008611933762">"Lejo"</string>
    <string name="deny" msgid="6632259981847676572">"Moho"</string>
    <string name="permission_request_notification_title" msgid="1810025922441048273">"Kërkohet leje"</string>
    <string name="permission_request_notification_with_subtitle" msgid="3743417870360129298">"Kërkohet leje\npër llogarinë <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="forward_intent_to_owner" msgid="4620359037192871015">"Po e përdor këtë aplikacion jashtë profilit tënd të punës"</string>
    <string name="forward_intent_to_work" msgid="3620262405636021151">"Këtë aplikacion po e përdor në profilin tënd të punës"</string>
    <string name="input_method_binding_label" msgid="1166731601721983656">"Metoda e hyrjeve"</string>
    <string name="sync_binding_label" msgid="469249309424662147">"Sinkronizo"</string>
    <string name="accessibility_binding_label" msgid="1974602776545801715">"Qasshmëria"</string>
    <string name="wallpaper_binding_label" msgid="1197440498000786738">"Imazhi i sfondit"</string>
    <string name="chooser_wallpaper" msgid="3082405680079923708">"Ndrysho imazhin e sfondit"</string>
    <string name="notification_listener_binding_label" msgid="2702165274471499713">"Dëgjues njoftimesh"</string>
    <string name="vr_listener_binding_label" msgid="8013112996671206429">"Dëgjues VR"</string>
    <string name="condition_provider_service_binding_label" msgid="8490641013951857673">"Ofrues kushtesh"</string>
    <string name="notification_ranker_binding_label" msgid="432708245635563763">"Shërbimi i klasifikimit të njoftimeve"</string>
    <string name="vpn_title" msgid="5906991595291514182">"VPN-ja u aktivizua"</string>
    <string name="vpn_title_long" msgid="6834144390504619998">"VPN-ja është aktivizuar nga <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="2275388920267251078">"Trokit për të menaxhuar rrjetin."</string>
    <string name="vpn_text_long" msgid="278540576806169831">"Lidhur me <xliff:g id="SESSION">%s</xliff:g>. Trokit për të menaxhuar rrjetin."</string>
    <string name="vpn_lockdown_connecting" msgid="6096725311950342607">"Po lidh VPN-në për aktivizim të përhershëm…"</string>
    <string name="vpn_lockdown_connected" msgid="2853127976590658469">"VPN e lidhur në mënyrë të përhershme"</string>
    <string name="vpn_lockdown_disconnected" msgid="5573611651300764955">"Shkëputur nga VPN-ja gjithmonë e aktivizuar"</string>
    <string name="vpn_lockdown_error" msgid="4453048646854247947">"Nuk mund të lidhej me VPN-në gjithmonë të aktivizuar"</string>
    <string name="vpn_lockdown_config" msgid="8331697329868252169">"Ndrysho rrjetin ose cilësimet e VPN-së"</string>
    <string name="upload_file" msgid="8651942222301634271">"Zgjidh skedarin"</string>
    <string name="no_file_chosen" msgid="4146295695162318057">"Nuk u zgjodh asnjë skedar"</string>
    <string name="reset" msgid="3865826612628171429">"Rivendos"</string>
    <string name="submit" msgid="862795280643405865">"Dërgo"</string>
    <string name="car_mode_disable_notification_title" msgid="8450693275833142896">"Aplikacioni i drejtimit të makinës është në ekzekutim"</string>
    <string name="car_mode_disable_notification_message" msgid="8954550232288567515">"Trokit për të dalë nga aplikacioni i drejtimit të makinës."</string>
    <string name="tethered_notification_title" msgid="2700523927485687353">"Lidhja e çiftimit ose ajo e qasjes në zona publike interneti është aktive"</string>
    <string name="tethered_notification_message" msgid="6228080755828019453">"Trokit për ta konfiguruar."</string>
    <string name="disable_tether_notification_title" msgid="7158047514545848391">"Lidhja e çiftimit është çaktivizuar"</string>
    <string name="disable_tether_notification_message" msgid="98281313984014775">"Kontakto me administratorin për detaje"</string>
    <string name="back_button_label" msgid="4078224038025043387">"Prapa"</string>
    <string name="next_button_label" msgid="6040209156399907780">"Përpara"</string>
    <string name="skip_button_label" msgid="3566599811326688389">"Kapërce"</string>
    <string name="no_matches" msgid="6472699895759164599">"Asnjë përputhje"</string>
    <string name="find_on_page" msgid="5400537367077438198">"Gjej brenda faqes"</string>
    <plurals name="matches_found" formatted="false" msgid="1101758718194295554">
      <item quantity="other"><xliff:g id="INDEX">%d</xliff:g> nga gjithsej <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="one">1 përputhje</item>
    </plurals>
    <string name="action_mode_done" msgid="2536182504764803222">"U krye!"</string>
    <string name="progress_erasing" msgid="6891435992721028004">"Po fshin hapësirën ruajtëse të brendshme…"</string>
    <string name="share" msgid="4157615043345227321">"Shpërndaj"</string>
    <string name="find" msgid="5015737188624767706">"Gjej"</string>
    <string name="websearch" msgid="5624340204512793290">"Kërkim në internet"</string>
    <string name="find_next" msgid="5341217051549648153">"Gjej tjetrën"</string>
    <string name="find_previous" msgid="4405898398141275532">"Gjej të mëparshmin"</string>
    <string name="gpsNotifTicker" msgid="3207361857637620780">"Kërkesë për vendndodhje nga <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="1590033371665669570">"Kërkesë për vendndodhje"</string>
    <string name="gpsNotifMessage" msgid="7346649122793758032">"Kërkuar nga <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="3719843080744112940">"Po"</string>
    <string name="gpsVerifNo" msgid="1671201856091564741">"Jo"</string>
    <string name="sync_too_many_deletes" msgid="6999440774578705300">"Kufiri i fshirjes u tejkalua"</string>
    <string name="sync_too_many_deletes_desc" msgid="7409327940303504440">"Ka <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> artikuj të fshirë për <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> nga llogaria <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>. Çfarë dëshiron të bësh?"</string>
    <string name="sync_really_delete" msgid="5657871730315579051">"Fshiji artikujt"</string>
    <string name="sync_undo_deletes" msgid="5786033331266418896">"Zhbëj fshirjet"</string>
    <string name="sync_do_nothing" msgid="4528734662446469646">"Mos bëj asgjë për momentin"</string>
    <string name="choose_account_label" msgid="5557833752759831548">"Zgjidh një llogari"</string>
    <string name="add_account_label" msgid="4067610644298737417">"Shto një llogari"</string>
    <string name="add_account_button_label" msgid="322390749416414097">"Shto llogari"</string>
    <string name="number_picker_increment_button" msgid="7621013714795186298">"Rrit"</string>
    <string name="number_picker_decrement_button" msgid="5116948444762708204">"Pakëso"</string>
    <string name="number_picker_increment_scroll_mode" msgid="8403893549806805985">"Prek dhe mbaj të shtypur <xliff:g id="VALUE">%s</xliff:g>."</string>
    <string name="number_picker_increment_scroll_action" msgid="8310191318914268271">"Rrëshqit lart për të rritur dhe poshtë për të pakësuar."</string>
    <string name="time_picker_increment_minute_button" msgid="7195870222945784300">"Rrit vlerat për minutë"</string>
    <string name="time_picker_decrement_minute_button" msgid="230925389943411490">"Pakëso vlerat për minutë"</string>
    <string name="time_picker_increment_hour_button" msgid="3063572723197178242">"Rrit vlerat për orë"</string>
    <string name="time_picker_decrement_hour_button" msgid="584101766855054412">"Pakëso vlerat për orë"</string>
    <string name="time_picker_increment_set_pm_button" msgid="5889149366900376419">"Cakto vlerat PM"</string>
    <string name="time_picker_decrement_set_am_button" msgid="1422608001541064087">"Cakto vlerat AM"</string>
    <string name="date_picker_increment_month_button" msgid="3447263316096060309">"Rrit vlerën mujore"</string>
    <string name="date_picker_decrement_month_button" msgid="6531888937036883014">"Pakëso vlerën mujore"</string>
    <string name="date_picker_increment_day_button" msgid="4349336637188534259">"Rrit vlerën ditore"</string>
    <string name="date_picker_decrement_day_button" msgid="6840253837656637248">"Pakëso vlerën ditore"</string>
    <string name="date_picker_increment_year_button" msgid="7608128783435372594">"Rrit vlerën vjetore"</string>
    <string name="date_picker_decrement_year_button" msgid="4102586521754172684">"Pakëso vlerën vjetore"</string>
    <string name="date_picker_prev_month_button" msgid="3418694374017868369">"Muaji i mëparshëm"</string>
    <string name="date_picker_next_month_button" msgid="4858207337779144840">"Muaji i ardhshëm"</string>
    <string name="keyboardview_keycode_alt" msgid="8997420058584292385">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="2134624484115716975">"Anulo"</string>
    <string name="keyboardview_keycode_delete" msgid="2661117313730098650">"Fshi"</string>
    <string name="keyboardview_keycode_done" msgid="2524518019001653851">"U krye!"</string>
    <string name="keyboardview_keycode_mode_change" msgid="2743735349997999020">"Ndryshim modaliteti"</string>
    <string name="keyboardview_keycode_shift" msgid="3026509237043975573">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="168054869339091055">"Enter"</string>
    <string name="activitychooserview_choose_application" msgid="3500574466367891463">"Zgjidh një aplikacion"</string>
    <string name="activitychooserview_choose_application_error" msgid="6937782107559241734">"Nuk mundi ta hapte <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="shareactionprovider_share_with" msgid="2753089758467748982">"Shpërnda publikisht me"</string>
    <string name="shareactionprovider_share_with_application" msgid="4902832247173666973">"Shpërnda me <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="982510275422590757">"Dorezë me rrëshqitje. Preke dhe mbaje të shtypur."</string>
    <string name="description_target_unlock_tablet" msgid="7431571180065859551">"Rrëshqit për të shkyçur."</string>
    <string name="action_bar_home_description" msgid="1501655419158631974">"Orientohu për në shtëpi"</string>
    <string name="action_bar_up_description" msgid="6611579697195026932">"Ngjitu lart"</string>
    <string name="action_menu_overflow_description" msgid="4579536843510088170">"Opsione të tjera"</string>
    <string name="action_bar_home_description_format" msgid="5087107531331621803">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="4346835454749569826">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="8490227947584914460">"Hapësira ruajtëse e brendshme e ndarë"</string>
    <string name="storage_sd_card" msgid="3404740277075331881">"Karta SD"</string>
    <string name="storage_sd_card_label" msgid="7526153141147470509">"Karta SD nga <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb_drive" msgid="448030813201444573">"USB-ja"</string>
    <string name="storage_usb_drive_label" msgid="6631740655876540521">"USB-ja nga <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb" msgid="2391213347883616886">"Hapësira ruajtëse e USB-së"</string>
    <string name="extract_edit_menu_button" msgid="63954536535863040">"Redakto"</string>
    <string name="data_usage_warning_title" msgid="9034893717078325845">"Paralajmërim për të dhënat"</string>
    <string name="data_usage_warning_body" msgid="1669325367188029454">"Ke përdorur <xliff:g id="APP">%s</xliff:g> nga të dhënat"</string>
    <string name="data_usage_mobile_limit_title" msgid="3911447354393775241">"U arrit kufiri i të dhënave"</string>
    <string name="data_usage_wifi_limit_title" msgid="2069698056520812232">"U arrit kufiri i të dhënave Wi-Fi"</string>
    <string name="data_usage_limit_body" msgid="3567699582000085710">"Të dhënat u ndërprenë për pjesën e mbetur të ciklit"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="101888478915677895">"Mbi kufirin e të dhënave celulare"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="1622359254521960508">"Mbi kufirin e të dhënave të Wi-Fi"</string>
    <string name="data_usage_limit_snoozed_body" msgid="545146591766765678">"Ke kaluar <xliff:g id="SIZE">%s</xliff:g> mbi kufirin tënd të caktuar"</string>
    <string name="data_usage_restricted_title" msgid="126711424380051268">"Të dhënat e sfondit janë të kufizuara"</string>
    <string name="data_usage_restricted_body" msgid="5338694433686077733">"Trokit për të hequr kufizimin."</string>
    <string name="data_usage_rapid_title" msgid="2950192123248740375">"Përdorim i lartë i të dhënave celulare"</string>
    <string name="data_usage_rapid_body" msgid="3886676853263693432">"Aplikacionet e tua kanë përdorur më shumë të dhëna se zakonisht"</string>
    <string name="data_usage_rapid_app_body" msgid="5425779218506513861">"<xliff:g id="APP">%s</xliff:g> ka përdorur më shumë të dhëna se zakonisht"</string>
    <string name="ssl_certificate" msgid="5690020361307261997">"Certifikatë sigurie"</string>
    <string name="ssl_certificate_is_valid" msgid="7293675884598527081">"Certifikata është e vlefshme."</string>
    <string name="issued_to" msgid="5975877665505297662">"Lëshuar për:"</string>
    <string name="common_name" msgid="1486334593631798443">"Emri i zakonshëm:"</string>
    <string name="org_name" msgid="7526331696464255245">"Organizata:"</string>
    <string name="org_unit" msgid="995934486977223076">"Njësia organizative:"</string>
    <string name="issued_by" msgid="7872459822431585684">"Lëshuar nga:"</string>
    <string name="validity_period" msgid="1717724283033175968">"Vlefshmëria:"</string>
    <string name="issued_on" msgid="5855489688152497307">"Lëshuar më:"</string>
    <string name="expires_on" msgid="1623640879705103121">"Skadon më:"</string>
    <string name="serial_number" msgid="3479576915806623429">"Numri serik:"</string>
    <string name="fingerprints" msgid="148690767172613723">"Shenjat e gishtave:"</string>
    <string name="sha256_fingerprint" msgid="7103976380961964600">"Gjurma e gishtit SHA-256:"</string>
    <string name="sha1_fingerprint" msgid="2339915142825390774">"Gjurma e gishtit SHA-1:"</string>
    <string name="activity_chooser_view_see_all" msgid="3917045206812726099">"Shikoji të gjitha"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="8880731437191978314">"Zgjidh aktivitetin"</string>
    <string name="share_action_provider_share_with" msgid="1904096863622941880">"Shpërnda publikisht me"</string>
    <string name="sending" msgid="206925243621664438">"Po dërgon…"</string>
    <string name="launchBrowserDefault" msgid="6328349989932924119">"Të hapet shfletuesi?"</string>
    <string name="SetupCallDefault" msgid="5581740063237175247">"Dëshiron ta pranosh telefonatën?"</string>
    <string name="activity_resolver_use_always" msgid="5575222334666843269">"Gjithmonë"</string>
    <string name="activity_resolver_set_always" msgid="4142825808921411476">"Caktoje si gjithmonë të hapur"</string>
    <string name="activity_resolver_use_once" msgid="948462794469672658">"Vetëm një herë"</string>
    <string name="activity_resolver_app_settings" msgid="6758823206817748026">"Cilësimet"</string>
    <string name="activity_resolver_work_profiles_support" msgid="4071345609235361269">"%1$s nuk e mbështet profilin e punës"</string>
    <string name="default_audio_route_name" product="tablet" msgid="367936735632195517">"Tablet"</string>
    <string name="default_audio_route_name" product="tv" msgid="4908971385068087367">"Televizori"</string>
    <string name="default_audio_route_name" product="default" msgid="9213546147739983977">"Telefon"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="1551166029093995289">"Altoparlantët e stacionit"</string>
    <string name="default_audio_route_name_hdmi" msgid="5474470558160717850">"HDMI"</string>
    <string name="default_audio_route_name_headphones" msgid="6954070994792640762">"Kufjet"</string>
    <string name="default_audio_route_name_usb" msgid="895668743163316932">"USB"</string>
    <string name="default_audio_route_category_name" msgid="5241740395748134483">"Sistemi"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="4214648773120426288">"Audioja e \"bluetooth-it\""</string>
    <string name="wireless_display_route_description" msgid="8297563323032966831">"Ekran pa tel"</string>
    <string name="media_route_button_content_description" msgid="2299223698196869956">"Transmeto"</string>
    <string name="media_route_chooser_title" msgid="6646594924991269208">"Lidhu me pajisjen"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3105906508794326446">"Transmeto ekranin në pajisje"</string>
    <string name="media_route_chooser_searching" msgid="6119673534251329535">"Po kërkon për pajisje…"</string>
    <string name="media_route_chooser_extended_settings" msgid="2506352159381327741">"Cilësimet"</string>
    <string name="media_route_controller_disconnect" msgid="7362617572732576959">"Shkëput"</string>
    <string name="media_route_status_scanning" msgid="8045156315309594482">"Po skanon..."</string>
    <string name="media_route_status_connecting" msgid="5845597961412010540">"Po lidhet..."</string>
    <string name="media_route_status_available" msgid="1477537663492007608">"Mundësohet"</string>
    <string name="media_route_status_not_available" msgid="480912417977515261">"Nuk mundësohet"</string>
    <string name="media_route_status_in_use" msgid="6684112905244944724">"Në përdorim"</string>
    <string name="display_manager_built_in_display_name" msgid="1015775198829722440">"Ekran i integruar"</string>
    <string name="display_manager_hdmi_display_name" msgid="1022758026251534975">"Ekran HDMI"</string>
    <string name="display_manager_overlay_display_name" msgid="5306088205181005861">"Mbivendosja #<xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="1480158037150469170">"<xliff:g id="NAME">%1$s</xliff:g>: <xliff:g id="WIDTH">%2$d</xliff:g>x<xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> ppi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="2810034719482834679">", i sigurt"</string>
    <string name="kg_forgot_pattern_button_text" msgid="406145459223122537">"Harrova motivin"</string>
    <string name="kg_wrong_pattern" msgid="1342812634464179931">"Motivi është i gabuar"</string>
    <string name="kg_wrong_password" msgid="2384677900494439426">"Fjalëkalim i gabuar"</string>
    <string name="kg_wrong_pin" msgid="3680925703673166482">"PIN-i është i gabuar"</string>
    <plurals name="kg_too_many_failed_attempts_countdown" formatted="false" msgid="236717428673283568">
      <item quantity="other">Provo sërish për <xliff:g id="NUMBER">%d</xliff:g> sekonda.</item>
      <item quantity="one">Provo sërish për 1 sekondë.</item>
    </plurals>
    <string name="kg_pattern_instructions" msgid="8366024510502517748">"Vizato motivin tënd"</string>
    <string name="kg_sim_pin_instructions" msgid="6479401489471690359">"Fut PIN-in e kartës SIM"</string>
    <string name="kg_pin_instructions" msgid="7355933174673539021">"Fut PIN-in"</string>
    <string name="kg_password_instructions" msgid="7179782578809398050">"Fut fjalëkalimin"</string>
    <string name="kg_puk_enter_puk_hint" msgid="6696187482616360994">"Karta SIM tani është e çaktivizuar. Fut kodin PUK për të vazhduar. Kontakto operatorin për detaje."</string>
    <string name="kg_puk_enter_pin_hint" msgid="8190982314659429770">"Fut kodin e dëshiruar të PIN-it"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="6372557107414074580">"Konfirmo kodin e dëshiruar PIN"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8871937892678885545">"Po shkyç kartën SIM…"</string>
    <string name="kg_password_wrong_pin_code" msgid="9013856346870572451">"Kodi PIN është i pasaktë."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="4821601451222564077">"Shkruaj një PIN me 4 deri në 8 numra."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="2539364558870734339">"Kodi PUK duhet të jetë me 8 numra."</string>
    <string name="kg_invalid_puk" msgid="4809502818518963344">"Fut kodin e saktë PUK. Provat e përsëritura do ta çaktivizojnë përgjithmonë kartën SIM."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="4705368340409816254">"Kodet PIN nuk përputhen"</string>
    <string name="kg_login_too_many_attempts" msgid="699292728290654121">"Shumë tentativa për motivin"</string>
    <string name="kg_login_instructions" msgid="3619844310339066827">"Për të shkyçur, identifikohu me llogarinë tënde të Google."</string>
    <string name="kg_login_username_hint" msgid="1765453775467133251">"Emri i përdoruesit (mail-i)"</string>
    <string name="kg_login_password_hint" msgid="3330530727273164402">"Fjalëkalimi"</string>
    <string name="kg_login_submit_button" msgid="893611277617096870">"Identifikohu"</string>
    <string name="kg_login_invalid_input" msgid="8292367491901220210">"Emër përdoruesi ose fjalëkalim i pavlefshëm."</string>
    <string name="kg_login_account_recovery_hint" msgid="4892466171043541248">"Harrove emrin e përdoruesit apo fjalëkalimin?\nVizito "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="4676010303243317253">"Po kontrollon llogarinë…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="23741434207544038">"E ke shkruar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë gabimisht PIN-in tënd.\n\n Provo sërish për <xliff:g id="NUMBER_1">%2$d</xliff:g> sekonda."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="3328686432962224215">"E ke shkruar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë gabimisht fjalëkalimin.\n\nProvo sërish për <xliff:g id="NUMBER_1">%2$d</xliff:g> sekonda."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="7357404233979139075">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për të vizatuar motivin tënd. \n\nProvo sërish për <xliff:g id="NUMBER_1">%2$d</xliff:g> sekonda."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="3479940221343361587">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për ta shkyçur tabletin tënd. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, tableti do të rivendoset në gjendje fabrike dhe të gjitha të dhënat e përdoruesit do të humbasin."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tv" msgid="7525614240870652051">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për ta shkyçur televizorin. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, televizori do të rivendoset në gjendjen e fabrikës dhe të gjitha të dhënat e përdoruesit do të humben."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="5955398963754432548">"Ke tentuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses për ta shkyçur telefonin tënd. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, telefoni do të rivendoset në gjendje fabrike dhe të gjitha të dhënat e përdoruesit do të humbasin."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2299099385175083308">"Ke tentuar <xliff:g id="NUMBER">%d</xliff:g> herë pa sukses për ta shkyçur tabletin tënd. Tableti tani do të rivendoset në gjendje fabrike."</string>
    <string name="kg_failed_attempts_now_wiping" product="tv" msgid="5213981402777341134">"Ke tentuar <xliff:g id="NUMBER">%d</xliff:g> herë ta shkyçësh pa sukses televizorin tënd. Televizori do të rivendoset tani si në gjendjen e fabrikës."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="5043730590446071189">"Ke tentuar <xliff:g id="NUMBER">%d</xliff:g> herë ta shkyçësh pa sukses telefonin tënd. Telefoni do të rivendoset tani si në gjendjen e fabrikës."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="7086799295109717623">"E ke vizatuar gabimisht motivin tënd të shkyçjes <xliff:g id="NUMBER_0">%1$d</xliff:g> herë. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme do të të kërkohet ta shkyçësh tabletin duke përdorur një llogari mail-i.\n\n Provo sërish për <xliff:g id="NUMBER_2">%3$d</xliff:g> sekonda."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="8057874855853116724">"Ke vizatuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses motivin tënd. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, do të të duhet ta shkyçësh televizorin duke përdorur një llogari mail-i.\n\n Provo sërish për <xliff:g id="NUMBER_2">%3$d</xliff:g> sekonda."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="5270861875006378092">"Ke vizatuar <xliff:g id="NUMBER_0">%1$d</xliff:g> herë pa sukses motivin tënd. Pas <xliff:g id="NUMBER_1">%2$d</xliff:g> tentativave të tjera të pasuksesshme, do të të duhet ta shkyçësh telefonin duke përdorur një llogari mail-i.\n\n Provo sërish për <xliff:g id="NUMBER_2">%3$d</xliff:g> sekonda."</string>
    <string name="kg_text_message_separator" product="default" msgid="4503708889934976866">" - "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="2034358143731750914">"Hiq"</string>
    <string name="safe_media_volume_warning" product="default" msgid="3751676824423049994">"Të ngrihet volumi mbi nivelin e rekomanduar?\n\nDëgjimi me volum të lartë për periudha të gjata mund të dëmtojë dëgjimin."</string>
    <string name="accessibility_shortcut_warning_dialog_title" msgid="4017995837692622933">"Të përdoret shkurtorja e qasshmërisë?"</string>
    <string name="accessibility_shortcut_toogle_warning" msgid="8306239551412868396">"Kur shkurtorja është e aktivizuar, shtypja e të dy butonave për 3 sekonda do të nisë një funksion qasshmërie.\n\n Funksioni aktual i qasshmërisë:\n <xliff:g id="SERVICE_NAME">%1$s</xliff:g>\n\n Mund ta ndryshosh funksionin te Cilësimet &gt; Qasshmëria."</string>
    <string name="disable_accessibility_shortcut" msgid="5806091378745232383">"Çaktivizo shkurtoren"</string>
    <string name="leave_accessibility_shortcut_on" msgid="6543362062336990814">"Përdor shkurtoren"</string>
    <string name="color_inversion_feature_name" msgid="326050048927789012">"Kthimi i ngjyrës"</string>
    <string name="color_correction_feature_name" msgid="3655077237805422597">"Korrigjimi i ngjyrës"</string>
    <string name="accessibility_shortcut_enabling_service" msgid="6141620395915529473">"Shkurtorja e qasshmërisë e aktivizoi <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_disabling_service" msgid="1287340429965172651">"Shkurtorja e qasshmërisë e çaktivizoi <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_spoken_feedback" msgid="4228997042855695090">"Shtyp dhe mbaj shtypur të dy butonat e volumit për tre sekonda për të përdorur <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_button_prompt_text" msgid="1634298854002673171">"Zgjidh një shërbim për ta përdorur kur troket butonin e qasshmërisë:"</string>
    <string name="accessibility_gesture_prompt_text" msgid="3271927619707898924">"Zgjidh një shërbim për ta përdorur me gjestin e qasshmërisë (rrëshqit shpejt lart nga fundi i ekranit me dy gishta):"</string>
    <string name="accessibility_gesture_3finger_prompt_text" msgid="218295923313037542">"Zgjidh një shërbim për ta përdorur me gjestin e qasshmërisë (rrëshqit shpejt lart nga fundi i ekranit me tre gishta):"</string>
    <string name="accessibility_button_instructional_text" msgid="8523635009916665153">"Për të kaluar mes shërbimeve, prek dhe mbaj të shtypur butonin e qasshmërisë."</string>
    <string name="accessibility_gesture_instructional_text" msgid="927882482331885974">"Për të kaluar mes pajisjeve, rrëshqit shpejt lart me dy gishta dhe mbaje prekur."</string>
    <string name="accessibility_gesture_3finger_instructional_text" msgid="7527523742771203377">"Për të kaluar mes pajisjeve, rrëshqit shpejt lart me tre gishta dhe mbaje prekur."</string>
    <string name="accessibility_magnification_chooser_text" msgid="1502075582164931596">"Zmadhimi"</string>
    <string name="user_switched" msgid="7249833311585228097">"Emri i përdoruesit aktual: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="user_switching_message" msgid="1912993630661332336">"Po kalon në <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="user_logging_out_message" msgid="7216437629179710359">"<xliff:g id="NAME">%1$s</xliff:g> po del…"</string>
    <string name="owner_name" msgid="8713560351570795743">"Zotëruesi"</string>
    <string name="error_message_title" msgid="4082495589294631966">"Gabim"</string>
    <string name="error_message_change_not_allowed" msgid="843159705042381454">"Ky ndryshim nuk lejohet nga administratori"</string>
    <string name="app_not_found" msgid="3429506115332341800">"Nuk u gjet asnjë aplikacion për të menaxhuar këtë veprim"</string>
    <string name="revoke" msgid="5526857743819590458">"Anulo"</string>
    <string name="mediasize_iso_a0" msgid="7039061159929977973">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="4063589931031977223">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="2779860175680233980">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3683469257246970630">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="752903572302658845">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3020439171949376572">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="6503671662530738180">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="8488649018955763878">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="3380506944389571030">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="7000627318995334730">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="4091511972200388310">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="2057859571254103889">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="4931975244795236924">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="4701978611340339483">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="3509735449039761603">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="486628178454656526">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="2507554073053511267">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="344189428571954711">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="7266158663658064799">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="5229204010533786299">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="2925910409602493256">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="8590530019536996218">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="6504734131385460314">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1751671704929443684">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="2935473413647925667">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="6835637985527663396">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="3000965043023118958">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="3846339505379333795">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8663097559661858303">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="4469290754678239705">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="1949330679635319183">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="3716843356839880581">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="2113667674722450076">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="1947253006814499213">"Letër"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="4056220626420245955">"Letër qeveritare"</string>
    <string name="mediasize_na_legal" msgid="8356233803828931150">"Ligjor"</string>
    <string name="mediasize_na_junior_legal" msgid="3398084874757748531">"Ligjor i ri"</string>
    <string name="mediasize_na_ledger" msgid="1819497882853940248">"Libër llogarish"</string>
    <string name="mediasize_na_tabloid" msgid="6792611672983574375">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="990821038991491710">"Kartë indeksi 3x5"</string>
    <string name="mediasize_na_index_4x6" msgid="4414381976602032401">"Karta e indeksit 4x6"</string>
    <string name="mediasize_na_index_5x8" msgid="4499341583361946948">"Kartë indeksi 5x8"</string>
    <string name="mediasize_na_monarch" msgid="4396943937986136896">"\"Monarch\""</string>
    <string name="mediasize_na_quarto" msgid="2119101847712239885">"\"Quatro\""</string>
    <string name="mediasize_na_foolscap" msgid="5011612828564394648">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="411670106572707544">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="7496706798725321898">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="946949835711037253">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="4704308592895046237">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1082996050478581675">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="7865122849174932948">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="852020506971633186">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3399567254628077606">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="2804330751361491000">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="7988760621340084314">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="90266288020939533">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7721316829399772162">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="7471455177845043180">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="6305242012782587594">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="8133982147973309032">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="5888548906612445289">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="6761433476186549691">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="6011047111717561836">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="1541865115368043069">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="8300341273885698803">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4329528623016980657">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="7340334955358311979">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="7403538361394953235">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="9024287678505132047">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="5151340021154579154">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="2709589944170908250">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="1209735840926222618">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="2137738196058117115">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="2533204016634398713">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="5976745918096025459">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="6841260581434101675">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="2112968853810337326">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="1575013107082530108">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="7290232592648122042">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="7477551750461028312">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="5552111912684384833">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3817016220446495613">"Vertikalisht i panjohur"</string>
    <string name="mediasize_unknown_landscape" msgid="1584741567225095325">"Orientim i panjohur horizontal"</string>
    <string name="write_fail_reason_cancelled" msgid="2344081488493969190">"Anuluar"</string>
    <string name="write_fail_reason_cannot_write" msgid="432118118378451508">"Gabim në shkrimin e përmbajtjes"</string>
    <string name="reason_unknown" msgid="5599739807581133337">"e panjohur"</string>
    <string name="reason_service_unavailable" msgid="5288405248063804713">"Shërbimi i printimit nuk është aktivizuar"</string>
    <string name="print_service_installed_title" msgid="6134880817336942482">"Shërbimi <xliff:g id="NAME">%s</xliff:g> u instalua"</string>
    <string name="print_service_installed_message" msgid="7005672469916968131">"Prek për të aktivizuar"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1199419462726962697">"Fut kodin PIN të administratorit"</string>
    <string name="restr_pin_enter_pin" msgid="373139384161304555">"Fut PIN-in"</string>
    <string name="restr_pin_incorrect" msgid="3861383632940852496">"I pasaktë"</string>
    <string name="restr_pin_enter_old_pin" msgid="7537079094090650967">"PIN-i aktual"</string>
    <string name="restr_pin_enter_new_pin" msgid="3267614461844565431">"PIN-i i ri"</string>
    <string name="restr_pin_confirm_pin" msgid="7143161971614944989">"Kofirmo PIN-in e ri"</string>
    <string name="restr_pin_create_pin" msgid="917067613896366033">"Krijo një PIN për modifikimin e kufizimeve"</string>
    <string name="restr_pin_error_doesnt_match" msgid="7063392698489280556">"PIN-et nuk përputhen. Provo sërish."</string>
    <string name="restr_pin_error_too_short" msgid="1547007808237941065">"PIN-i është shumë i shkurtër. Duhet të jetë të paktën 4 shifra."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="4427486903285216153">
      <item quantity="other">Provo sërish brenda <xliff:g id="COUNT">%d</xliff:g> sekondave</item>
      <item quantity="one">Provo sërish brenda 1 sekonde</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="5897719962541636727">"Provo sërish më vonë"</string>
    <string name="immersive_cling_title" msgid="2307034298721541791">"Po shikon ekranin e plotë"</string>
    <string name="immersive_cling_description" msgid="7092737175345204832">"Për të dalë, rrëshqit nga lart poshtë."</string>
    <string name="immersive_cling_positive" msgid="7047498036346489883">"E kuptova"</string>
    <string name="done_label" msgid="7283767013231718521">"U krye!"</string>
    <string name="hour_picker_description" msgid="5153757582093524635">"Rrëshqitësi rrethor i orëve"</string>
    <string name="minute_picker_description" msgid="9029797023621927294">"Rrëshqitësi rrethor i minutave"</string>
    <string name="select_hours" msgid="5982889657313147347">"Përzgjidh orët"</string>
    <string name="select_minutes" msgid="9157401137441014032">"Përzgjidh minutat"</string>
    <string name="select_day" msgid="2060371240117403147">"Përzgjidh muajin dhe ditën"</string>
    <string name="select_year" msgid="1868350712095595393">"Përzgjidh vitin"</string>
    <string name="deleted_key" msgid="9130083334943364001">"<xliff:g id="KEY">%1$s</xliff:g> u fshi"</string>
    <string name="managed_profile_label_badge" msgid="6762559569999499495">"Puna <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_2" msgid="5673187309555352550">"<xliff:g id="LABEL">%1$s</xliff:g> i dytë i punës"</string>
    <string name="managed_profile_label_badge_3" msgid="6882151970556391957">"<xliff:g id="LABEL">%1$s</xliff:g> i tretë i punës"</string>
    <string name="lock_to_app_unlock_pin" msgid="3890940811866290782">"Zhgozhdimi kërkon PIN-in"</string>
    <string name="lock_to_app_unlock_pattern" msgid="2694204070499712503">"Kërko model shkyçjeje para heqjes së gozhdimit"</string>
    <string name="lock_to_app_unlock_password" msgid="9126722403506560473">"Kërko fjalëkalim para heqjes nga gozhdimi."</string>
    <string name="package_installed_device_owner" msgid="7035926868974878525">"Instaluar nga administratori"</string>
    <string name="package_updated_device_owner" msgid="7560272363805506941">"Përditësuar nga administratori"</string>
    <string name="package_deleted_device_owner" msgid="2292335928930293023">"Fshirë nga administratori"</string>
    <string name="confirm_battery_saver" msgid="5247976246208245754">"Në rregull"</string>
    <string name="battery_saver_description_with_learn_more" msgid="1817385558636532621">"Për të rritur kohëzgjatjen e baterisë, \"Kursyesi i baterisë\":\n·Aktivizon \"Temën e errët\"\n·Çaktivizon ose kufizon aktivitetin në sfond, disa efekte vizuale dhe veçori të tjera si “Ok Google”\n\n"<annotation id="url">"Mëso më shumë"</annotation></string>
    <string name="battery_saver_description" msgid="7618492104632328184">"Për të rritur kohëzgjatjen e baterisë, \"Kursyesi i baterisë\":\n·Aktivizon \"Temën e errët\"\n·Çaktivizon ose kufizon aktivitetin në sfond, disa efekte vizuale dhe veçori të tjera si “Ok Google”"</string>
    <string name="data_saver_description" msgid="4995164271550590517">"Për të ndihmuar në reduktimin e përdorimit të të dhënave, \"Kursyesi i të dhënave\" pengon që disa aplikacione të dërgojnë apo të marrin të dhëna në sfond. Një aplikacion që po përdor aktualisht mund të ketë qasje te të dhënat, por këtë mund ta bëjë më rrallë. Kjo mund të nënkuptojë, për shembull, se imazhet nuk shfaqen kur troket mbi to."</string>
    <string name="data_saver_enable_title" msgid="7080620065745260137">"Të aktivizohet \"Kursyesi i të dhënave\"?"</string>
    <string name="data_saver_enable_button" msgid="4399405762586419726">"Aktivizo"</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="2877101784123058273">
      <item quantity="other">Për %1$d minuta (deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Për një minutë (deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="4230730310318858312">
      <item quantity="other">Për %1$d minutë (deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Për 1 minutë (deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="7725354244196466758">
      <item quantity="other">Për %1$d orë (deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Për 1 orë (deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="588719069121765642">
      <item quantity="other">Për %1$d orë (deri në <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Për 1 orë (deri në <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="1148568456958944998">
      <item quantity="other">Për %d minuta</item>
      <item quantity="one">Për një minutë</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2742377799995454859">
      <item quantity="other">Për %d minuta</item>
      <item quantity="one">Për 1 minutë</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="525401855645490022">
      <item quantity="other">Për %d orë</item>
      <item quantity="one">Për 1 orë</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="7644653189680911640">
      <item quantity="other">Për %d orë</item>
      <item quantity="one">Për 1 orë</item>
    </plurals>
    <string name="zen_mode_until" msgid="2250286190237669079">"Deri në <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_alarm" msgid="7046911727540499275">"Deri në <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> (alarmi tjetër)"</string>
    <string name="zen_mode_forever" msgid="740585666364912448">"Derisa ta çaktivizosh"</string>
    <string name="zen_mode_forever_dnd" msgid="3423201955704180067">"Deri sa të çaktivizosh gjendjen \"Mos shqetëso\""</string>
    <string name="zen_mode_rule_name_combination" msgid="7174598364351313725">"<xliff:g id="FIRST">%1$s</xliff:g> / <xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="8009920446193610996">"Shpalos"</string>
    <string name="zen_mode_feature_name" msgid="3785547207263754500">"Mos shqetëso"</string>
    <string name="zen_mode_downtime_feature_name" msgid="5886005761431427128">"periudha joaktive"</string>
    <string name="zen_mode_default_weeknights_name" msgid="7902108149994062847">"Netët e javës"</string>
    <string name="zen_mode_default_weekends_name" msgid="4707200272709377930">"Fundjava"</string>
    <string name="zen_mode_default_events_name" msgid="2280682960128512257">"Ngjarje"</string>
    <string name="zen_mode_default_every_night_name" msgid="1467765312174275823">"Në gjumë"</string>
    <string name="muted_by" msgid="91464083490094950">"<xliff:g id="THIRD_PARTY">%1$s</xliff:g> po çaktivizon disa tinguj"</string>
    <string name="system_error_wipe_data" msgid="5910572292172208493">"Ka një problem të brendshëm me pajisjen tënde. Ajo mund të jetë e paqëndrueshme derisa të rivendosësh të dhënat në gjendje fabrike."</string>
    <string name="system_error_manufacturer" msgid="703545241070116315">"Ka një problem të brendshëm me pajisjen tënde. Kontakto prodhuesin tënd për detaje."</string>
    <string name="stk_cc_ussd_to_dial" msgid="3139884150741157610">"Kërkesa USSD u ndryshua në telefonatë të rregullt"</string>
    <string name="stk_cc_ussd_to_ss" msgid="4826846653052609738">"Kërkesa USSD u ndryshua në kërkesë SS"</string>
    <string name="stk_cc_ussd_to_ussd" msgid="8343001461299302472">"U ndryshua në kërkesë të re USSD"</string>
    <string name="stk_cc_ussd_to_dial_video" msgid="429118590323618623">"Kërkesa USSD u ndryshua në telefonatë me video"</string>
    <string name="stk_cc_ss_to_dial" msgid="4087396658768717077">"Kërkesa SS u ndryshua në telefonatë të rregullt"</string>
    <string name="stk_cc_ss_to_dial_video" msgid="1324194624384312664">"Kërkesa SS u ndryshua në telefonatë me video"</string>
    <string name="stk_cc_ss_to_ussd" msgid="8417905193112944760">"Kërkesa SS u ndryshua në kërkesë USSD"</string>
    <string name="stk_cc_ss_to_ss" msgid="132040645206514450">"U ndryshua në kërkesë të re SS"</string>
    <string name="notification_work_profile_content_description" msgid="5296477955677725799">"Profili i punës"</string>
    <string name="notification_alerted_content_description" msgid="6139691253611265992">"Sinjalizuar"</string>
    <string name="expand_button_content_description_collapsed" msgid="3873368935659010279">"Zgjero"</string>
    <string name="expand_button_content_description_expanded" msgid="7484217944948667489">"Palos"</string>
    <string name="expand_action_accessibility" msgid="1947657036871746627">"aktivizo zgjerimin"</string>
    <string name="usb_midi_peripheral_name" msgid="490523464968655741">"Porta periferike USB e Androidit"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7557148557088787741">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="2836276258480904434">"Porta periferike USB"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="2260297653578167367">"Opsione të tjera"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="3949818077708138098">"Mbylle tejkalimin"</string>
    <string name="maximize_button_text" msgid="4258922519914732645">"Maksimizo"</string>
    <string name="close_button_text" msgid="10603510034455258">"Mbyll"</string>
    <string name="notification_messaging_title_template" msgid="772857526770251989">"<xliff:g id="CONVERSATION_TITLE">%1$s</xliff:g>: <xliff:g id="SENDER_NAME">%2$s</xliff:g>"</string>
    <plurals name="selected_count" formatted="false" msgid="3946212171128200491">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> të zgjedhura</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> i zgjedhur</item>
    </plurals>
    <string name="default_notification_channel_label" msgid="3697928973567217330">"E pakategorizuara"</string>
    <string name="importance_from_user" msgid="2782756722448800447">"Ke caktuar rëndësinë e këtyre njoftimeve."</string>
    <string name="importance_from_person" msgid="4235804979664465383">"Është i rëndësishëm për shkak të personave të përfshirë."</string>
    <string name="user_creation_account_exists" msgid="2239146360099708035">"Të lejohet <xliff:g id="APP">%1$s</xliff:g> që të krijojë një përdorues të ri me <xliff:g id="ACCOUNT">%2$s</xliff:g> (një përdorues me këtë llogari ekziston tashmë) ?"</string>
    <string name="user_creation_adding" msgid="7305185499667958364">"Të lejohet <xliff:g id="APP">%1$s</xliff:g> që të krijojë një përdorues të ri me <xliff:g id="ACCOUNT">%2$s</xliff:g> ?"</string>
    <string name="language_selection_title" msgid="52674936078683285">"Shto një gjuhë"</string>
    <string name="country_selection_title" msgid="5221495687299014379">"Preferenca e rajonit"</string>
    <string name="search_language_hint" msgid="7004225294308793583">"Shkruaj emrin e gjuhës"</string>
    <string name="language_picker_section_suggested" msgid="6556199184638990447">"Sugjeruar"</string>
    <string name="language_picker_section_all" msgid="1985809075777564284">"Të gjitha gjuhët"</string>
    <string name="region_picker_section_all" msgid="756441309928774155">"Të gjitha rajonet"</string>
    <string name="locale_search_menu" msgid="6258090710176422934">"Kërko"</string>
    <string name="app_suspended_title" msgid="888873445010322650">"Aplikacioni nuk ofrohet"</string>
    <string name="app_suspended_default_message" msgid="6451215678552004172">"<xliff:g id="APP_NAME_0">%1$s</xliff:g> nuk ofrohet në këtë moment. Kjo menaxhohet nga <xliff:g id="APP_NAME_1">%2$s</xliff:g>."</string>
    <string name="app_suspended_more_details" msgid="211260942831587014">"Mëso më shumë"</string>
    <string name="work_mode_off_title" msgid="5503291976647976560">"Të aktivizohet profili i punës?"</string>
    <string name="work_mode_off_message" msgid="8417484421098563803">"Aplikacionet e punës, njoftimet, të dhënat e tua dhe funksionet e tjera të profilit të punës do të aktivizohen"</string>
    <string name="work_mode_turn_on" msgid="3662561662475962285">"Aktivizo"</string>
    <string name="deprecated_target_sdk_message" msgid="5203207875657579953">"Ky aplikacion është ndërtuar për një version më të vjetër të Android dhe mund të mos funksionojë mirë. Provo të kontrollosh për përditësime ose kontakto me zhvilluesin."</string>
    <string name="deprecated_target_sdk_app_store" msgid="8456784048558808909">"Kontrollo për përditësim"</string>
    <string name="new_sms_notification_title" msgid="6528758221319927107">"Ke mesazhe të reja"</string>
    <string name="new_sms_notification_content" msgid="3197949934153460639">"Hap aplikacionin SMS për ta parë"</string>
    <string name="profile_encrypted_title" msgid="9001208667521266472">"Disa funksione mund të jenë të kufizuara"</string>
    <string name="profile_encrypted_detail" msgid="5279730442756849055">"Profili i punës është i kyçur"</string>
    <string name="profile_encrypted_message" msgid="1128512616293157802">"Trokit për ta shkyçur profilin e punës"</string>
    <string name="usb_mtp_launch_notification_title" msgid="774319638256707227">"U lidh me <xliff:g id="PRODUCT_NAME">%1$s</xliff:g>"</string>
    <string name="usb_mtp_launch_notification_description" msgid="6942535713629852684">"Trokit për të parë skedarët"</string>
    <string name="pin_target" msgid="8036028973110156895">"Gozhdo"</string>
    <string name="unpin_target" msgid="3963318576590204447">"Zhgozhdo"</string>
    <string name="app_info" msgid="6113278084877079851">"Informacioni mbi aplikacionin"</string>
    <string name="negative_duration" msgid="1938335096972945232">"−<xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="demo_starting_message" msgid="6577581216125805905">"Po nis demonstrimin..."</string>
    <string name="demo_restarting_message" msgid="1160053183701746766">"Po rivendos pajisjen…"</string>
    <string name="suspended_widget_accessibility" msgid="6331451091851326101">"<xliff:g id="LABEL">%1$s</xliff:g> u çaktivizua"</string>
    <string name="conference_call" msgid="5731633152336490471">"Telefonatë konferencë"</string>
    <string name="tooltip_popup_title" msgid="7863719020269945722">"Këshilla për veglën"</string>
    <string name="app_category_game" msgid="4534216074910244790">"Lojëra"</string>
    <string name="app_category_audio" msgid="8296029904794676222">"Muzikë dhe audio"</string>
    <string name="app_category_video" msgid="2590183854839565814">"Filma dhe video"</string>
    <string name="app_category_image" msgid="7307840291864213007">"Foto dhe imazhe"</string>
    <string name="app_category_social" msgid="2278269325488344054">"Rrjete sociale dhe komunikim"</string>
    <string name="app_category_news" msgid="1172762719574964544">"Lajme dhe revista"</string>
    <string name="app_category_maps" msgid="6395725487922533156">"Harta dhe navigim"</string>
    <string name="app_category_productivity" msgid="1844422703029557883">"Produktivitet"</string>
    <string name="device_storage_monitor_notification_channel" msgid="5164244565844470758">"Hapësira ruajtëse e pajisjes"</string>
    <string name="adb_debugging_notification_channel_tv" msgid="4764046459631031496">"Korrigjimi i USB-së"</string>
    <string name="time_picker_hour_label" msgid="4208590187662336864">"orë"</string>
    <string name="time_picker_minute_label" msgid="8307452311269824553">"minutë"</string>
    <string name="time_picker_header_text" msgid="9073802285051516688">"Vendos orën"</string>
    <string name="time_picker_input_error" msgid="8386271930742451034">"Fut një kohë të vlefshme"</string>
    <string name="time_picker_prompt_label" msgid="303588544656363889">"Shkruaj orën"</string>
    <string name="time_picker_text_input_mode_description" msgid="4761160667516611576">"Kalo te modaliteti i hyrjes së tekstit për hyrjen e kohës."</string>
    <string name="time_picker_radial_mode_description" msgid="1222342577115016953">"Kalo te modaliteti i orës për hyrjen e kohës."</string>
    <string name="autofill_picker_accessibility_title" msgid="4425806874792196599">"Opsionet e plotësimit automatik"</string>
    <string name="autofill_save_accessibility_title" msgid="1523225776218450005">"Ruaje për \"Plotësim automatik\""</string>
    <string name="autofill_error_cannot_autofill" msgid="6528827648643138596">"Përmbajtjet nuk mund të plotësohen automatikisht"</string>
    <string name="autofill_picker_no_suggestions" msgid="1076022650427481509">"Asnjë sugjerim për plotësim automatik"</string>
    <plurals name="autofill_picker_some_suggestions" formatted="false" msgid="6651883186966959978">
      <item quantity="other"><xliff:g id="COUNT">%1$s</xliff:g> sugjerime për plotësim automatik</item>
      <item quantity="one">Një sugjerim për plotësim automatik</item>
    </plurals>
    <string name="autofill_save_title" msgid="7719802414283739775">"Të ruhet te "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_type" msgid="3002460014579799605">"Të ruhet <xliff:g id="TYPE">%1$s</xliff:g> te "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_2types" msgid="3783270967447869241">"Të ruhet <xliff:g id="TYPE_0">%1$s</xliff:g> dhe <xliff:g id="TYPE_1">%2$s</xliff:g> te "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_3types" msgid="6598228952100102578">"Të ruhet <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> dhe <xliff:g id="TYPE_2">%3$s</xliff:g> te "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title" msgid="3630695947047069136">"Të përditësohet në "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_type" msgid="5264152633488495704">"Të përditësohet <xliff:g id="TYPE">%1$s</xliff:g> në "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_2types" msgid="1797514386321086273">"Të përditësohet <xliff:g id="TYPE_0">%1$s</xliff:g> dhe <xliff:g id="TYPE_1">%2$s</xliff:g> në "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_3types" msgid="1312232153076212291">"Të përditësohen këta artikuj në "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>": <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> dhe <xliff:g id="TYPE_2">%3$s</xliff:g> ?"</string>
    <string name="autofill_save_yes" msgid="8035743017382012850">"Ruaj"</string>
    <string name="autofill_save_no" msgid="9212826374207023544">"Jo, faleminderit"</string>
    <string name="autofill_update_yes" msgid="4608662968996874445">"Përditëso"</string>
    <string name="autofill_save_type_password" msgid="5624528786144539944">"fjalëkalimi"</string>
    <string name="autofill_save_type_address" msgid="3111006395818252885">"adresa"</string>
    <string name="autofill_save_type_credit_card" msgid="3583795235862046693">"karta e kreditit"</string>
    <string name="autofill_save_type_username" msgid="1018816929884640882">"emri i përdoruesit"</string>
    <string name="autofill_save_type_email_address" msgid="1303262336895591924">"adresa e mail-it"</string>
    <string name="etws_primary_default_message_earthquake" msgid="8401079517718280669">"Qëndro i qetë dhe kërko strehim në afërsi."</string>
    <string name="etws_primary_default_message_tsunami" msgid="5828171463387976279">"Evakuohu menjëherë nga rajonet bregdetare dhe zonat pranë lumenjve drejt një vendi më të sigurt, si për shembull në një terren të ngritur."</string>
    <string name="etws_primary_default_message_earthquake_and_tsunami" msgid="4888224011071875068">"Qëndro i qetë dhe kërko strehim në afërsi."</string>
    <string name="etws_primary_default_message_test" msgid="4583367373909549421">"Testim për mesazhet e urgjencës"</string>
    <string name="notification_reply_button_accessibility" msgid="5235776156579456126">"Përgjigju"</string>
    <string name="etws_primary_default_message_others" msgid="7958161706019130739"></string>
    <string name="mmcc_authentication_reject" msgid="4891965994643876369">"Karta SIM nuk lejohet për zërin"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="227760698553988751">"Karta SIM nuk është e përgatitur për zërin"</string>
    <string name="mmcc_illegal_ms" msgid="7509650265233909445">"Karta SIM nuk lejohet për zërin"</string>
    <string name="mmcc_illegal_me" msgid="6505557881889904915">"Telefoni nuk lejohet për zërin"</string>
    <string name="mmcc_authentication_reject_msim_template" msgid="4480853038909922153">"Karta SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nuk lejohet"</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template" msgid="3688508325248599657">"Karta SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nuk është përgatitur"</string>
    <string name="mmcc_illegal_ms_msim_template" msgid="832644375774599327">"Karta SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nuk lejohet"</string>
    <string name="mmcc_illegal_me_msim_template" msgid="4802735138861422802">"Karta SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nuk lejohet"</string>
    <string name="popup_window_default_title" msgid="6907717596694826919">"Dritare kërcyese"</string>
    <string name="slice_more_content" msgid="3377367737876888459">"+ <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="shortcut_restored_on_lower_version" msgid="9206301954024286063">"Versioni i aplikacionit u ul ose nuk është në përputhje me këtë shkurtore"</string>
    <string name="shortcut_restore_not_supported" msgid="4763198938588468400">"Nuk mund të restaurohej shkurtorja sepse aplikacioni nuk mbështet rezervimin dhe restaurimin"</string>
    <string name="shortcut_restore_signature_mismatch" msgid="579345304221605479">"Nuk mund të restaurohej shkurtorja për shkak të mospërputhjes së nënshkrimit të aplikacionit"</string>
    <string name="shortcut_restore_unknown_issue" msgid="2478146134395982154">"Nuk mund të restaurohej shkurtorja"</string>
    <string name="shortcut_disabled_reason_unknown" msgid="753074793553599166">"Shkurtorja është çaktivizuar"</string>
    <string name="harmful_app_warning_uninstall" msgid="6472912975664191772">"ÇINSTALO"</string>
    <string name="harmful_app_warning_open_anyway" msgid="5963657791740211807">"HAPE GJITHSESI"</string>
    <string name="harmful_app_warning_title" msgid="8794823880881113856">"U gjet aplikacion i dëmshëm"</string>
    <string name="slices_permission_request" msgid="3677129866636153406">"<xliff:g id="APP_0">%1$s</xliff:g> dëshiron të shfaqë pjesë të <xliff:g id="APP_2">%2$s</xliff:g>"</string>
    <string name="screenshot_edit" msgid="7408934887203689207">"Modifiko"</string>
    <string name="volume_dialog_ringer_guidance_vibrate" msgid="2055927873175228519">"Do të lëshojë dridhje për telefonatat dhe njoftimet"</string>
    <string name="volume_dialog_ringer_guidance_silent" msgid="1011246774949993783">"Do të hiqet zëri për telefonatat dhe njoftimet"</string>
    <string name="notification_channel_system_changes" msgid="2462010596920209678">"Ndryshimet e sistemit"</string>
    <string name="notification_channel_do_not_disturb" msgid="7832584281883687653">"Mos shqetëso"</string>
    <string name="zen_upgrade_notification_visd_title" msgid="2001148984371968620">"E re: Modaliteti \"Mos shqetëso\" po fsheh njoftimet"</string>
    <string name="zen_upgrade_notification_visd_content" msgid="3683314609114134946">"Trokit për të mësuar më shumë dhe për të ndryshuar."</string>
    <string name="zen_upgrade_notification_title" msgid="8198167698095298717">"\"Mos shqetëso\" ka ndryshuar"</string>
    <string name="zen_upgrade_notification_content" msgid="5228458567180124005">"Trokit për të shënuar atë që është bllokuar"</string>
    <string name="notification_app_name_system" msgid="3045196791746735601">"Sistemi"</string>
    <string name="notification_app_name_settings" msgid="9088548800899952531">"Cilësimet"</string>
    <string name="notification_appops_camera_active" msgid="8177643089272352083">"Kamera"</string>
    <string name="notification_appops_microphone_active" msgid="581333393214739332">"Mikrofoni"</string>
    <string name="notification_appops_overlay_active" msgid="5571732753262836481">"po shfaqet mbi aplikacionet e tjera në ekranin tënd"</string>
    <string name="dynamic_mode_notification_channel_name" msgid="2986926422100223328">"Njoftimi i informacionit të \"Modalitetit rutinë\""</string>
    <string name="dynamic_mode_notification_title" msgid="9205715501274608016">"Bateria mund të mbarojë përpara ngarkimit të zakonshëm"</string>
    <string name="dynamic_mode_notification_summary" msgid="4141614604437372157">"\"Kursyesi i baterisë\" u aktivizua për të zgjatur jetëgjatësinë e baterisë"</string>
    <string name="battery_saver_notification_channel_name" msgid="3918243458067916913">"Kursyesi i baterisë"</string>
    <string name="battery_saver_sticky_disabled_notification_title" msgid="616803848887159814">"\"Kursyesi i baterisë\" nuk do të aktivizohet përsëri derisa bateria të jetë përsëri në nivel të ulët"</string>
    <string name="battery_saver_sticky_disabled_notification_summary" msgid="9091127514013090563">"Bateria është karikuar në një nivel të mjaftueshëm. \"Kursyesi i baterisë\" nuk do të aktivizohet përsëri deri sa bateria të jetë përsëri në nivel të ulët."</string>
    <string name="battery_saver_charged_notification_title" product="default" msgid="3323003634503470433">"Telefoni është karikuar në <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="tablet" msgid="7917739170436791596">"Tableti është karikuar në <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="device" msgid="6316898726189914805">"Pajisja është karikuar në <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_notification_summary" msgid="8489738830261291526">"\"Kursyesi i baterisë\" është joaktiv. Funksionet nuk janë më të kufizuara."</string>
    <string name="battery_saver_off_alternative_notification_summary" msgid="8875240624827898671">"\"Kursyesi i baterisë\" është çaktivizuar. Funksionet nuk janë më të kufizuara."</string>
    <string name="mime_type_folder" msgid="2203536499348787650">"Dosje"</string>
    <string name="mime_type_apk" msgid="3168784749499623902">"Aplikacion i Android"</string>
    <string name="mime_type_generic" msgid="4606589110116560228">"Skedar"</string>
    <string name="mime_type_generic_ext" msgid="9220220924380909486">"Skedar <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_audio" msgid="4933450584432509875">"Audio"</string>
    <string name="mime_type_audio_ext" msgid="2615491023840514797">"Audio <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_video" msgid="7071965726609428150">"Video"</string>
    <string name="mime_type_video_ext" msgid="185438149044230136">"Video <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_image" msgid="2134307276151645257">"Imazh"</string>
    <string name="mime_type_image_ext" msgid="5743552697560999471">"Imazh <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_compressed" msgid="8737300936080662063">"Arkiv"</string>
    <string name="mime_type_compressed_ext" msgid="4775627287994475737">"Arkiv <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_document" msgid="3737256839487088554">"Dokument"</string>
    <string name="mime_type_document_ext" msgid="2398002765046677311">"Dokument <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_spreadsheet" msgid="8188407519131275838">"Fletëllogaritëse"</string>
    <string name="mime_type_spreadsheet_ext" msgid="8720173181137254414">"Fletëllogaritëse <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_presentation" msgid="1145384236788242075">"Prezantim"</string>
    <string name="mime_type_presentation_ext" msgid="8761049335564371468">"Prezantim <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="car_loading_profile" msgid="8219978381196748070">"Po ngarkohet"</string>
    <plurals name="file_count" formatted="false" msgid="7063513834724389247">
      <item quantity="other"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> skedarë</item>
      <item quantity="one"><xliff:g id="FILE_NAME_0">%s</xliff:g> + <xliff:g id="COUNT_1">%d</xliff:g> skedar</item>
    </plurals>
    <string name="chooser_no_direct_share_targets" msgid="492542066060841139">"Ndarja e drejtpërdrejtë nuk ofrohet"</string>
    <string name="chooser_all_apps_button_label" msgid="3230427756238666328">"Lista e aplikacioneve"</string>
</resources>
