<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2014 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="settings_app_name" msgid="7931201304065140909">"Cilësimet"</string>
    <string name="launcher_settings_app_name" msgid="1459269619779675736">"Cilësimet"</string>
    <string name="launcher_network_app_name" msgid="8311763462169735002">"Rrjeti"</string>
    <string name="launcher_restricted_profile_app_name" msgid="3324091425480935205">"Profil i kufizuar"</string>
    <string name="general_action_yes" msgid="1303080504548165355">"Po"</string>
    <string name="general_action_no" msgid="674735073031386948">"Jo"</string>
    <string name="action_on_title" msgid="1074972820237738324">"Aktiv"</string>
    <string name="action_off_title" msgid="3598665702863436597">"Joaktiv"</string>
    <string name="action_on_description" msgid="9146557891514835767">"Aktiv"</string>
    <string name="action_off_description" msgid="1368039592272701910">"Joaktiv"</string>
    <string name="agree" msgid="8155497436593889753">"Pranoj"</string>
    <string name="disagree" msgid="7402998517682194430">"Nuk pranoj"</string>
    <string name="enabled" msgid="5127188665060746381">"Aktiv"</string>
    <string name="disabled" msgid="4589065923272201387">"Joaktiv"</string>
    <string name="unavailable" msgid="1610732303812180196">"Nuk ofrohet"</string>
    <string name="allow" msgid="6982558814345894019">"Lejo"</string>
    <string name="deny" msgid="8291577308813053917">"Refuzo"</string>
    <string name="header_category_suggestions" msgid="106077820663753645">"Sugjerime"</string>
    <string name="header_category_quick_settings" msgid="3785334008768367890">"Cilësimet e shpejta"</string>
    <string name="header_category_general_settings" msgid="3897615781153506434">"Cilësimet e përgjithshme"</string>
    <string name="dismiss_suggestion" msgid="6200814545590126814">"Largo sugjerimin"</string>
    <string name="hotwording_title" msgid="2606899304616599026">"Zbulimi i \"Ok Google\""</string>
    <string name="hotwording_summary" msgid="2170375928302175449">"Flit me \"Asistentin e Google\" në çdo kohë"</string>
    <string name="header_category_device" msgid="3023893663454705969">"Pajisja"</string>
    <string name="header_category_preferences" msgid="3738388885555798797">"Preferencat"</string>
    <string name="header_category_accessories" msgid="6479803330480847199">"Telekomanda dhe aksesorët"</string>
    <string name="header_category_personal" msgid="7880053929985150368">"Personale"</string>
    <string name="connect_to_network" msgid="4133686359319492392">"Lidhu me rrjetin"</string>
    <string name="add_an_account" msgid="2601275122685226096">"Shto një llogari"</string>
    <string name="accounts_category_title" msgid="6645304075809033585">"Llogaritë dhe profilet"</string>
    <string name="accounts_category_summary_no_account" msgid="3053606166993074648">"Asnjë llogari"</string>
    <string name="accounts_category_summary" msgid="7617932110389860822">"{count,plural, =1{# llogari}other{# llogari}}"</string>
    <string name="accounts_slice_summary" msgid="1571012157154521119">"Shërbimet e medias, \"Asistenti\", pagesat"</string>
    <string name="connectivity_network_category_title" msgid="8226264889892008114">"Rrjeti dhe interneti"</string>
    <string name="sound_category_title" msgid="7899816751041939518">"Tingulli"</string>
    <string name="applications_category_title" msgid="7112019490898586223">"Aplikacionet"</string>
    <string name="device_pref_category_title" msgid="8292572846154873762">"Preferencat e pajisjes"</string>
    <string name="accessibility_category_title" msgid="1552664829936369592">"Qasshmëria"</string>
    <string name="remotes_and_accessories_category_title" msgid="4795119810430255047">"Telekomandat dhe aksesorët"</string>
    <string name="display_and_sound_category_title" msgid="9203309625380755860">"Ekrani dhe tingulli"</string>
    <string name="help_and_feedback_category_title" msgid="7036505833991003031">"Ndihmë dhe komente"</string>
    <string name="privacy_category_title" msgid="8552430590908463601">"Privatësia"</string>
    <string name="privacy_device_settings_category" msgid="5018334603278648524">"Cilësimet e pajisjes"</string>
    <string name="privacy_account_settings_category" msgid="5786591549945777400">"Cilësimet e llogarisë"</string>
    <string name="privacy_device_lock_settings_title" msgid="2859882209591786575">"Kyçja e pajisjes"</string>
    <string name="privacy_assistant_settings_title" msgid="4524957824712623680">"Asistenti i Google"</string>
    <string name="privacy_purchases_settings_title" msgid="6490965297061569673">"Pagesa dhe blerjet"</string>
    <string name="privacy_app_settings_category" msgid="858250971978879266">"Cilësimet e aplikacionit"</string>
    <string name="privacy_category_summary" msgid="3534434883380511043">"Vendndodhja, përdorimi dhe diagnostikimi, reklamat"</string>
    <string name="add_account" msgid="7386223854837017129">"Shto një llogari"</string>
    <string name="unknown_account" msgid="5159580666787047518">"Llogari e panjohur"</string>
    <string name="account_header_remove_account" msgid="8573697553061331373">"Hiq llogarinë"</string>
    <string name="account_sync" msgid="4315295293211313989">"Zgjidh aplikacionet e sinkronizuara"</string>
    <string name="sync_now" msgid="4335217984374620551">"Sinkronizo tani"</string>
    <string name="sync_in_progress" msgid="8081367667406185785">"Po sinkronizohet..."</string>
    <string name="last_synced" msgid="8371967816955123864">"Sinkronizuar së fundi më <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="sync_disabled" msgid="6652778349371079140">"Çaktivizuar"</string>
    <string name="account_remove" msgid="8456848988853890155">"Hiq llogarinë"</string>
    <string name="account_remove_failed" msgid="5654411101098531690">"Llogaria nuk mund të hiqet"</string>
    <!-- no translation found for sync_item_title (5884138264243772176) -->
    <skip />
    <string name="sync_one_time_sync" msgid="1665961083810584134">"Sinkronizo tani<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_failed" msgid="2998289556481804047">"Sinkronizimi dështoi"</string>
    <string name="sync_active" msgid="1621239982176888680">"Sinkronizimi është aktiv"</string>
    <string name="connectivity_wifi" msgid="1138689464484009184">"Wi-Fi"</string>
    <string name="connectivity_ethernet" msgid="4270588618633681766">"Eterneti"</string>
    <string name="connectivity_summary_ethernet_connected" msgid="2612843587731520061">"Eterneti u lidh"</string>
    <string name="connectivity_summary_no_network_connected" msgid="6111160695454212460">"Nuk është lidhur asnjë rrjet"</string>
    <string name="connectivity_summary_wifi_disabled" msgid="7819225159680467324">"Wi-Fi është çaktivizuar"</string>
    <string name="unplug_ethernet_to_use_wifi" msgid="5078499991407069670">"Shkëput Ethernet për të përdorur Wi-Fi"</string>
    <string name="wifi_setting_always_scan" msgid="431846292711998602">"Skanimi gjithmonë në dispozicion"</string>
    <string name="wifi_setting_always_scan_context" msgid="1092998659666221222">"Lejo shërbimin e vendndodhjes së Google dhe aplikacione të tjera të skanojnë për rrjete, edhe kur Wi-Fi është joaktiv"</string>
    <string name="wifi_setting_always_scan_content_description" msgid="484630053450137332">"\"Skanimi ofrohet gjithmonë\", lejo shërbimin e vendndodhjes së Google dhe aplikacione të tjera të skanojnë për rrjete, edhe kur Wi-Fi është joaktiv"</string>
    <string name="wifi_setting_enable_wifi" msgid="5276730445393952969">"Wi-Fi"</string>
    <string name="connectivity_hint_message" msgid="5638304246522516583">"Lidhu me rrjetin"</string>
    <string name="connectivity_network_diagnostics" msgid="4396132865849151854">"Diagnostikimi i rrjetit"</string>
    <string name="apps_recently_used_category_title" msgid="7877660412428813933">"Aplikacionet e hapura së fundi"</string>
    <string name="apps_see_all_apps" msgid="2002886135933443688">"Shiko të gjitha aplikacionet"</string>
    <string name="apps_permissions_category_title" msgid="8099660060701465267">"Lejet"</string>
    <string name="overlay_security_slice_title" msgid="4895032817538300187"></string>
    <string name="update_slice_title" msgid="6553763903108611747"></string>
    <string name="all_apps_title" msgid="3717294436135280133">"Të gjitha aplikacionet"</string>
    <string name="all_apps_show_system_apps" msgid="1260688031005374302">"Shfaq aplikacionet e sistemit"</string>
    <string name="all_apps_installed" msgid="8217778476185598971">"Aplikacionet e instaluara"</string>
    <string name="all_apps_other" msgid="4420174882983813158">"Aplikacionet e sistemit"</string>
    <string name="all_apps_disabled" msgid="2776041242863791053">"Aplikacionet e çaktivizuara"</string>
    <string name="device_daydream" msgid="2631191946958113220">"Mbrojtësi i ekranit"</string>
    <string name="device_display" msgid="244634591698925025">"Ekrani"</string>
    <string name="device_display_sound" msgid="7399153506435649193">"Ekrani dhe tingulli"</string>
    <string name="device_sound" msgid="8616320533559404963">"Tingulli"</string>
    <string name="device_surround_sound" msgid="1889436002598316470">"Tingulli rrethues"</string>
    <string name="device_sound_effects" msgid="2000295001122684957">"Tingujt e sistemit"</string>
    <string name="device_apps" msgid="2134756632245008919">"Aplikacionet"</string>
    <string name="device_storage" msgid="8540243547121791073">"Hapësira ruajtëse"</string>
    <string name="device_reset" msgid="6115282675800077867">"Rivendos në gjendje fabrike"</string>
    <string name="device_backup_restore" msgid="3634531946308269398">"Rezervo dhe restauro"</string>
    <string name="device_factory_reset" msgid="1110189450013225971">"Rivendosja e të dhënave të fabrikës"</string>
    <string name="device_calibration" msgid="2907914144048739705">"Kalibrimi"</string>
    <string name="device_energy_saver" msgid="6611757996220443028">"Kohëmatësi i fikjes"</string>
    <string name="device_energy_saver_summary" msgid="5306058475316008429">"Cakto kohëmatësit për të fikur televizorin dhe kursyer energji"</string>
    <string name="overlay_internal_slice_title" msgid="6427352417573831625"></string>
    <string name="device_fastpair" msgid="1235240814051277047">"Pajisjet"</string>
    <string name="surround_sound_select_formats" msgid="6070283650131226239">"Zgjidh formatet"</string>
    <string name="surround_sound_category_title" msgid="5688539514178173911">"Tingulli rrethues"</string>
    <string name="surround_sound_format_ac3" msgid="4759143098751306492">"Dolby Digital"</string>
    <string name="surround_sound_format_e_ac3" msgid="6923129088903887242">"Dolby Digital Plus"</string>
    <string name="surround_sound_format_dts" msgid="8331816247117135587">"DTS"</string>
    <string name="surround_sound_format_dts_hd" msgid="4268947520371740146">"DTS-HD"</string>
    <string name="surround_sound_format_dts_uhd" msgid="4340749818133578788">"DTS:X"</string>
    <string name="surround_sound_format_dolby_mat" msgid="3029804841912462928">"Dolby Atmos me Dolby TrueHD"</string>
    <string name="surround_sound_format_dolby_truehd" msgid="5113046743572967088">"Dolby TrueHD"</string>
    <string name="surround_sound_format_e_ac3_joc" msgid="3360344066462262996">"Dolby Atmos me Dolby Digital Plus"</string>
    <string name="surround_sound_format_dra" msgid="6102878163986662443">"DRA"</string>
    <string name="surround_sound_auto_info" msgid="4829346839183591680">"Shënim. Opsioni \"Automatik\" mund të mos funksionojë nëse pajisja nuk i raporton saktë formatet e mbështetura."</string>
    <string name="surround_sound_auto_title" msgid="4892922385727913277">"Automatike: Aktivizo vetëm formatet që mbështeten nga pajisja jote e daljes së audios "</string>
    <string name="surround_sound_auto_summary" msgid="7073023654150720285">"Kur përzgjidhet, sistemi do të lejojë që aplikacionet të zgjedhin çdo format tingulli që mbështetet nga zinxhiri i pajisjeve të tua. Aplikacionet mund të zgjedhin një format që nuk është formati i cilësisë më të lartë."</string>
    <string name="surround_sound_none_title" msgid="1600095173519889326">"Asnjë: Asnjëherë mos përdor tingull rrethues"</string>
    <string name="surround_sound_manual_title" msgid="4935447605070985537">"Manuale: Aktivizo ose çaktivizo me përzgjedhje çdo format të mbështetur nga kjo pajisje, pavarësisht se çfarë mbështetet nga pajisja jote e daljes së audios."</string>
    <string name="surround_sound_manual_summary" msgid="5155535847461070572">"Kur zgjidhet, mund të çaktivizosh manualisht formatet e tingujve që mbështeten nga zinxhiri i pajisjeve të tua që shkaktojnë probleme me luajtjen. Formatet e tingujve që nuk mbështeten nga zinxhiri i pajisjeve të tua mund të aktivizohen. Në disa raste, aplikacionet mund të zgjedhin një format që nuk është formati i cilësisë më të lartë."</string>
    <string name="surround_sound_enable_unsupported_dialog_title" msgid="9155579373370356463">"Po aktivizon një format të pambështetur të tingullit?"</string>
    <string name="surround_sound_enable_unsupported_dialog_desc" msgid="1901648758103522741">"Pajisja audio e lidhur nuk raporton mbështetjen për këtë format. Kjo mund të shkaktojë sjellje të papritura si p.sh. zhurma të larta ose kërcitje nga pajisja jote."</string>
    <string name="surround_sound_enable_unsupported_dialog_cancel" msgid="3499147437078761105">"Anulo"</string>
    <string name="surround_sound_enable_unsupported_dialog_ok" msgid="7466983147896640444">"Ndrysho gjithsesi"</string>
    <string name="surround_sound_supported_title" msgid="4873195851187547020">"FORMATET E MBËSHTETURA"</string>
    <string name="surround_sound_unsupported_title" msgid="2302820271700954900">"FORMATET E PAMBËSHTETURA"</string>
    <string name="surround_sound_format_info" msgid="5671866505653542934">"INFORMACIONI I FORMATIT"</string>
    <string name="surround_sound_show_formats" msgid="1929849219042916469">"Shfaq formatet"</string>
    <string name="surround_sound_hide_formats" msgid="7770931097236868238">"Fshih formatet"</string>
    <string name="surround_sound_enabled_formats" msgid="5159269040069877148">"FORMATET E AKTIVIZUARA"</string>
    <string name="surround_sound_disabled_formats" msgid="2250466936859455802">"FORMATET E ÇAKTIVIZUARA"</string>
    <string name="surround_sound_disabled_format_info_clicked" msgid="463393349034930031">"Për ta aktivizuar, ndryshoje përzgjedhjen e formatit në \"Manuale\"."</string>
    <string name="surround_sound_enabled_format_info_clicked" msgid="4003154853054756792">"Për ta çaktivizuar, ndryshoje përzgjedhjen e formatit në \"Manuale\"."</string>
    <string name="display_category_title" msgid="247804007525046312">"Ekrani"</string>
    <string name="advanced_display_settings_title" msgid="6293280819870140631">"Cilësimet e përparuara të ekranit"</string>
    <string name="hdmi_cec_settings_title" msgid="7120729705063868627">"HDMI-CEC"</string>
    <string name="advanced_sound_settings_title" msgid="319921303039469139">"Cilësimet e përparuara të tingullit"</string>
    <string name="game_mode_title" msgid="7280816243531315755">"Lejo modalitetin e lojës"</string>
    <string name="match_content_dynamic_range_title" msgid="2794980556561655838">"Përshtate me gamën dinamike të përmbajtjes"</string>
    <string name="match_content_dynamic_range_summary" msgid="2255683926227355398">"Kur aktivizohet ky opsion, sistemi do të kalojë midis formateve të ndryshme të gamës dinamike për t\'u përputhur me përmbajtjen. Kjo mund të shkaktojë një ekran të zi gjatë ndërrimit të formatit.\n\nKliko \"Cilësimet e përparuara të ekranit\" për më shumë opsione të gamës dinamike."</string>
    <string name="preferred_dynamic_range_title" msgid="5064883672337010588">"Gama e preferuar dinamike"</string>
    <string name="preferred_dynamic_range_selection_system_title" msgid="4505030483876080996">"Konvertimi i preferuar nga sistemi"</string>
    <string name="preferred_dynamic_range_selection_system_desc" msgid="2765115460108291217">"Lejon që sistemi të menaxhojë konvertimin e formatit"</string>
    <string name="preferred_dynamic_range_selection_system_summary" msgid="4509062596428781094">"Kur ky opsion është i zgjedhur, sistemi do të përcaktojë një gamë dinamike të përshtatshme për t\'u dërguar në ekranin tënd dhe për ta konvertuar përmbajtjen në këtë gamë dinamike sipas nevojës."</string>
    <string name="preferred_dynamic_range_selection_passthrough_desc" msgid="4831260397179583737">"Përputhet gjithmonë me formatin e përmbajtjes"</string>
    <string name="preferred_dynamic_range_selection_force_title" msgid="4448836594133973103">"Zbato me forcë konvertimin"</string>
    <string name="preferred_dynamic_range_selection_force_desc" msgid="1418542349290684513">"Zbaton me forcë konvertimin në formatin e preferuar"</string>
    <string name="preferred_dynamic_range_selection_force_summary" msgid="8381058061765216239">"Kaloje me forcë konvertimin në një format të preferuar. Zbatimi me forcë i konvertimit mund të ketë ndikim në cilësimet e tjera në modalitetin e ekranit ose në formatin HDR."</string>
    <string name="preferred_dynamic_range_selection_force_sdr_title" msgid="3135104063034317252">"Gjithmonë në SDR"</string>
    <string name="preferred_dynamic_range_selection_force_hdr_title" msgid="1032587815433139859">"Gjithmonë në <xliff:g id="HDR_TYPE">%s</xliff:g>"</string>
    <string name="preferred_dynamic_range_force_dialog_title" msgid="6865110024863661702">"Dëshiron të zbatosh me forcë daljen në HDR?"</string>
    <string name="preferred_dynamic_range_force_dialog_desc" msgid="7758323258282201656">"Si parazgjedhje, konvertimi do të kalohet me forcë në <xliff:g id="HDR_TYPE">%s</xliff:g>."</string>
    <string name="preferred_dynamic_range_force_dialog_desc_4k30_issue" msgid="4938418395391206131">"Ekrani yt do të funksionojë me rezolucion 1080p 60 Hz. Ky opsion nuk është i përputhshëm me ekranin tënd kur ai funksionon me rezolucion 4k 60 Hz."</string>
    <string name="selection_dolby_vision_not_supported_sidebar" msgid="8994591316574824115">"Dolby Vision nuk mbështetet në rezolucionin aktual. Nëse e aktivizon Dolby Vision në mënyrë manuale, rezolucioni i ekranit tënd do të kalohet në 1080p 60 Hz"</string>
    <string name="manual_dolby_vision_format_on_4k60_title" msgid="4172263676512376500">"Të ndryshohet rezolucioni në 1080p 60 Hz?"</string>
    <string name="dynamic_range_selection_force_dv_title" msgid="8070148109262327094">"Zbato gjithmonë me forcë konvertimin në Dolby Vision"</string>
    <string name="dynamic_range_selection_force_dv_summary" msgid="1052851029985095562">"Nëse Dolby Vision është çaktivizuar në \"Formatet HDR\" te \"Cilësimet e përparuara të ekranit\", zbatimi me detyrim i konvertimit në Dolby Vision do ta aktivizojë përsëri atë."</string>
    <string name="dynamic_range_selection_force_hdr10_title" msgid="1221688206945051384">"Zbato gjithmonë me forcë konvertimin në HDR10"</string>
    <string name="dynamic_range_selection_force_hdr10_summary" msgid="7784573527636502784">"Nëse HDR10 është çaktivizuar në \"Formatet HDR\" te \"Cilësimet e përparuara të ekranit\", zbatimi me detyrim i konvertimit në HDR10 do ta aktivizojë përsëri atë."</string>
    <string name="dynamic_range_selection_force_hlg_title" msgid="3976190987768712696">"Zbato gjithmonë me forcë konvertimin në HLG"</string>
    <string name="dynamic_range_selection_force_hlg_summary" msgid="5371949016689544001">"Nëse HLG është çaktivizuar në \"Formatet HDR\" te \"Cilësimet e përparuara të ekranit\", zbatimi me detyrim i konvertimit në HLG do ta aktivizojë përsëri atë."</string>
    <string name="dynamic_range_selection_force_hdr10plus_title" msgid="1305556000063625735">"Zbato gjithmonë me forcë konvertimin në HDR10+"</string>
    <string name="dynamic_range_selection_force_hdr10plus_summary" msgid="918038386222537401">"Nëse HDR10+ është çaktivizuar në \"Formatet HDR\" te \"Cilësimet e përparuara të ekranit\", zbatimi me detyrim i konvertimit në HDR10+ do ta aktivizojë përsëri atë."</string>
    <string name="dynamic_range_selection_force_sdr_title" msgid="1063579223517652945">"Zbato gjithmonë me forcë konvertimin në SDR"</string>
    <string name="dynamic_range_selection_force_sdr_summary" msgid="2874771365465898941">"Zbatimi me forcë i konvertimit në SDR do të çaktivizojë të gjitha formatet në \"Formatet HDR\" te \"Cilësimet e përplaruara të ekranit\"."</string>
    <string name="match_content_frame_rate_title" msgid="153291168560947689">"Përshtat shpejtësinë e kuadrove të përmbajtjes"</string>
    <string name="match_content_frame_rate_seamless" msgid="5577846750811067585">"Vetëm pa ndërprerje"</string>
    <string name="match_content_frame_rate_seamless_summary" msgid="2737466163964133210">"Nëse aplikacioni e kërkon, pajisja jote do ta përshtatë daljen e saj me shpejtësinë origjinale të kuadrove që shikon, VETËM nëse televizori mund të kryejë një kalim të thjeshtuar."</string>
    <string name="match_content_frame_rate_seamless_not_supported_summary" msgid="98559950465123792">"Ekrani yt i lidhur nuk mbështet kalimet pa ndërprerje të shpejtësisë së rifreskimit. Ky opsion nuk do të ketë asnjë efekt nëse nuk e ndryshon në një ekran që e mbështet atë."</string>
    <string name="match_content_frame_rate_non_seamless" msgid="2702658727234710031">"Gjithmonë"</string>
    <string name="match_content_frame_rate_non_seamless_summary" msgid="6831699459487130055">"Nëse aplikacioni e kërkon, pajisja jote do ta përshtatë daljen e saj me shpejtësinë origjinale të kuadrove që shikon. Kjo mund të bëjë që ekrani të jetë bosh për një sekondë kur del ose hyn në luajtjen e një videoje."</string>
    <string name="match_content_frame_rate_never" msgid="1678354793095148423">"Asnjëherë"</string>
    <string name="match_content_frame_rate_never_summary" msgid="742977618080396095">"Edhe nëse aplikacioni e kërkon, pajisja jote asnjëherë nuk do të përpiqet ta përshtatë daljen e saj me shpejtësinë origjinale të kuadrove që shikon."</string>
    <string name="font_scale_settings_title" msgid="4114019544800225980">"Shkallëzimi i tekstit"</string>
    <string name="font_scale_item_detail" msgid="1558315053348778805">"Shkalla në <xliff:g id="SCALE">%1$d</xliff:g>%%"</string>
    <string name="font_scale_sample_text_title" msgid="5239266611413037261">"Teksti shembull"</string>
    <string name="font_scale_preview_text_title" msgid="8056182208511371119">"Magjistari i mrekullueshëm i Ozit"</string>
    <string name="font_scale_preview_text_subtitle" msgid="677394182922188048">"Kapitulli 11: Qyteti i mrekullueshëm i smeraldtë i Ozit"</string>
    <string name="font_scale_preview_text_body" msgid="7890679265084738383">"Edhe me sytë e mbrojtur nga syzet e gjelbra, Doroti dhe shokët e saj u dalldisën në fillim nga shkëlqimi i Qytetit të mrekullueshëm. Rrugët ishin të mbushura me shtëpi të bukura të gjitha të ndërtuara me mermer të gjelbër dhe kudo shkëlqenin prej tyre smeralde. Ata shëtitën në një trotuar me po të njëjtin mermer të gjelbër dhe aty ku blloqet bashkoheshin kishte radhë të tjera smeraldi, ngjitur me njëra-tjetrën, dhe që shkëlqenin nën ndriçimin e diellit. Dritaret ishin me xhama të gjelbër; edhe qielli mbi Qytet kishte një nuancë të gjelbër, dhe rrezet e diellit ishin të gjelbra. \n\nKishte shumë njerëz, burra, gra dhe fëmijë që shëtisnin dhe të gjithë ishin të veshur me rroba të gjelbra dhe kishin lëkurë të gjelbër. Ata e shikonin Dorotin dhe shoqëruesit e saj të çuditshëm me sy të habitur, dhe fëmijët të gjithë u trembën dhe u fshehën pas nënave kur panë Luanin, por askush nuk u foli. Në rrugë kishte shumë dyqane dhe Doroti pa se gjithçka brenda tyre ishte e gjelbër. Shiteshin karamele të gjelbra dhe kokoshka të gjelbra, si dhe këpucë të gjelbra, kapele të gjelbra dhe rroba të gjelbra të të gjitha llojeve. Në një vend dikush shiste limonadë të gjelbër dhe kur fëmijët blinin, Doroti pa se ata paguanin me monedha të gjelbra. \n\nDukej sikur nuk kishte kuaj apo kafshë të ndonjë lloji; burrat i transportonin sendet me karroca të vogla të gjelbra, të cilat i shtynin përpara. Të gjithë dukeshin të kënaqur, të lumtur dhe të begatë."</string>
    <string name="hdr_format_selection_title" msgid="4042679694363850581">"Zgjedhja e formatit"</string>
    <string name="hdr_format_selection_auto_title" msgid="2370148695440344232">"Automatik"</string>
    <string name="hdr_format_selection_manual_title" msgid="2077604650196987438">"Manuale"</string>
    <string name="hdr_format_selection_auto_desc" msgid="1542210944552409996">"Përdor formatet e raportuara të pajisjes"</string>
    <string name="hdr_format_selection_manual_desc" msgid="8865649615882146772">"Zgjidh formatet në mënyrë manuale nga formatet e ofruara"</string>
    <string name="hdr_format_supported_title" msgid="1458594819224612431">"FORMATET E MBËSHTETURA"</string>
    <string name="hdr_format_unsupported_title" msgid="715318408107924941">"FORMATET E PAMBËSHTETURA"</string>
    <string name="hdr_format_sdr" msgid="7211377112392255102">"SDR"</string>
    <string name="hdr_format_hdr10" msgid="8063543267227491062">"HDR10"</string>
    <string name="hdr_format_hlg" msgid="454510079939620321">"HLG"</string>
    <string name="hdr_format_hdr10plus" msgid="4371652089162162876">"HDR10+"</string>
    <string name="hdr_format_dolby_vision" msgid="7367264615042999587">"Dolby Vision"</string>
    <string name="hdr_format_selection_auto_summary" msgid="7384637194191436727">"Kur zgjidhet, sistemi do të lejojë që aplikacionet të zgjedhin çdo format HDR që mbështetet nga zinxhiri yt i pajisjeve. Aplikacionet mund të zgjedhin një format që nuk është formati i cilësisë më të lartë."</string>
    <string name="hdr_format_selection_manual_summary" msgid="7886959642083639353">"Kur zgjidhet, mund të çaktivizosh manualisht formatet HDR që mbështeten nga zinxhiri i pajisjeve të tua që shkaktojnë probleme me luajtjen. Formatet HDR që nuk mbështeten nga zinxhiri i pajisjeve të tua nuk mund të aktivizohen me detyrim. Aplikacionet mund të zgjedhin një format që nuk është formati i cilësisë më të lartë."</string>
    <string name="hdr_format_info" msgid="5652559220799426076">"INFORMACIONI I FORMATIT"</string>
    <string name="hdr_show_formats" msgid="171065892975445851">"Shfaq formatet"</string>
    <string name="hdr_hide_formats" msgid="8561568998525727230">"Fshih formatet"</string>
    <string name="hdr_enabled_formats" msgid="8527870623949982774">"FORMATET E AKTIVIZUARA"</string>
    <string name="hdr_disabled_formats" msgid="4758522849421497896">"FORMATET E ÇAKTIVIZUARA"</string>
    <string name="hdr_enabled_format_info_clicked" msgid="1466675962665861040">"Për ta çaktivizuar, ndryshoje përzgjedhjen e formatit në \"Manuale\"."</string>
    <string name="resolution_selection_title" msgid="2873993320284587853">"Rezolucioni"</string>
    <string name="resolution_selection_auto_title" msgid="4738671207331027385">"Automatik"</string>
    <string name="resolution_selection_dialog_title" msgid="4029798035133645272">"Rezolucioni është ndryshuar"</string>
    <string name="resolution_selection_with_mode_dialog_title" msgid="5011192408613100514">"Të ndryshohet rezolucioni në %1$s?"</string>
    <string name="resolution_selection_dialog_desc" msgid="3667357611495669701">"Zgjidh \"Në rregull\" për të përdorur %1$s nga tani e tutje."</string>
    <string name="resolution_selection_disabled_dolby_vision_dialog_desc" msgid="7952404018654828187">"Dolby Vision nuk mbështetet në %1$s dhe do të çaktivizohet te \"Cilësimet e përparuara të ekranit\""</string>
    <string name="resolution_hdr_description_info" msgid="2408761621976850238">"Ky modalitet mbështet: %1$s\nNë disa televizorë mund të duhet të aktivizosh lidhjen HDMI të përparuar për të aktivizuar formate të tjera HDR. Kontrollo cilësimet e televizorit për të parë nëse kjo mbështetet."</string>
    <string name="resolution_selection_dialog_cancel" msgid="3683616572317946129">"Anulo"</string>
    <string name="resolution_selection_dialog_ok" msgid="3123351228545013492">"Në rregull"</string>
    <string name="resolution_selection_hz" msgid="4425902505388495637">"Hz"</string>
    <string name="resolution_display_mode" msgid="6633857172598855480">"<xliff:g id="RESOLUTION">%1$s</xliff:g> (<xliff:g id="REFRESH_RATE">%2$s</xliff:g> Hz)"</string>
    <string name="device_storage_clear_cache_title" msgid="14370154552302965">"Të pastrohen të dhënat e memories specifike?"</string>
    <string name="device_storage_clear_cache_message" msgid="4352802738505831032">"Kjo do të pastrojë të dhënat e memories specifike për të gjitha aplikacionet."</string>
    <string name="default_audio_output_settings_title" msgid="5441937324539531999"></string>
    <string name="accessories_add" msgid="413764175035531452">"Shto një aksesor"</string>
    <string name="accessory_state_pairing" msgid="15908899628218319">"Po çiftohet..."</string>
    <string name="accessory_state_connecting" msgid="6560241025917621212">"Po lidhet..."</string>
    <string name="accessory_state_error" msgid="8353621828816824428">"Nuk mund të çiftohej"</string>
    <string name="accessory_state_canceled" msgid="4794837663402063770">"U anulua"</string>
    <string name="accessory_state_paired" msgid="3296695242499532000">"I çiftuar"</string>
    <string name="accessory_options" msgid="774592782382321681">"Aksesori"</string>
    <string name="accessory_unpair" msgid="2473411128146068804">"Anulo çiftimin"</string>
    <string name="accessory_battery" msgid="2283700366184703548">"Bateria <xliff:g id="PERCENTAGE">%1$d</xliff:g>%%"</string>
    <string name="accessory_unpairing" msgid="2529195578082286563">"Çiftimi i pajisjes po anulohet…"</string>
    <string name="accessory_connected" msgid="5229574480869175180">"U lidh"</string>
    <string name="accessory_change_name" msgid="6493717176878500683">"Ndrysho emrin"</string>
    <string name="accessory_change_name_title" msgid="451188562035392238">"Fut një emër të ri për këtë aksesor"</string>
    <string name="accessories_add_accessibility_title" msgid="1300294413423909579">"Çiftimi me Bluetooth."</string>
    <string name="accessories_add_title" msgid="7704824893011194433">"Po kërkon për aksesorë…"</string>
    <string name="accessories_add_bluetooth_inst" msgid="2508151218328384366">"Para se të çiftosh pajisjet e tua me Bluetooth, sigurohu që të jenë në modalitetin e çiftimit."</string>
    <string name="accessories_autopair_msg" msgid="2501824457418285019">"U gjet një pajisje dhe ajo do të çiftohet automatikisht pas <xliff:g id="COUNTDOWN">%1$s</xliff:g> sekondash"</string>
    <string name="error_action_not_supported" msgid="5377532621386080296">"Ky veprim nuk mbështetet"</string>
    <string name="bluetooth_pairing_request" msgid="6120176967230348092">"Kërkesë çiftimi me Bluetooth"</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="7397401633869153520">"Për ta çiftuar me: &lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;, sigurohu që të tregojë këtë çelës kalimi: &lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="8587851808387685613">"Nga: &lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;Të çiftohet me këtë pajisje?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="6934651048757228432">"Për ta çiftuar me: &lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;Shkruaj në të: &lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;, më pas shtyp \"Kthehu\" ose Enter."</string>
    <string name="bluetooth_enter_pin_msg" msgid="8905524093007140634">"Për ta çiftuar me: &lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;, &lt;br&gt;Shkruaj kodin PIN të kërkuar të pajisjes:"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="889584097447402492">"Për ta çiftuar me: &lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;, &lt;br&gt;Shkruaj çelësin e kalimit të kërkuar të pajisjes:"</string>
    <string name="bluetooth_pin_values_hint" msgid="6237371515577342950">"Zakonisht 0000 ose 1234"</string>
    <string name="bluetooth_pair" msgid="2410285813728786067">"Çifto"</string>
    <string name="bluetooth_cancel" msgid="4415185529332987034">"Anulo"</string>
    <string name="bluetooth_device_connected_toast" msgid="1896195197089204806">"%1$s u lidh"</string>
    <string name="bluetooth_device_disconnected_toast" msgid="7459239447363156499">"%1$s u shkëput"</string>
    <string name="connected_devices_slice_pref_title" msgid="6761921505544005991">"Telekomandat dhe aksesorët"</string>
    <string name="bluetooth_toggle_title" msgid="3808904783456336104">"Bluetooth"</string>
    <string name="bluetooth_toggle_confirmation_dialog_title" msgid="3906746631391295717">"Çaktivizo Bluetooth-in"</string>
    <string name="bluetooth_toggle_confirmation_dialog_summary" msgid="9017044450625172698">"Nuk do të mund të qasesh tek \"Asistenti i Google\" nga telekomanda jote ndërkohë që Bluetooth-i është joaktiv."</string>
    <string name="bluetooth_pair_accessory" msgid="5508750142754420984">"Çifto aksesorin"</string>
    <string name="bluetooth_known_devices_category" msgid="6895470515631452961">"Aksesorët"</string>
    <string name="bluetooth_official_remote_category" msgid="5817814488268307170">"Telekomanda"</string>
    <string name="bluetooth_official_remote_entry_title" msgid="6699700335229570038">"Cilësimet e telekomandës"</string>
    <string name="bluetooth_ir_entry_title" msgid="6927284710576530479">"Konfiguro butonat e telekomandës"</string>
    <string name="bluetooth_ir_entry_subtitle" msgid="4606207128353416151">"Kontrollo volumin, energjinë dhe hyrjen në televizorë, marrës dhe soundbar-ë"</string>
    <string name="bluetooth_connect_action_title" msgid="7715342395313781643">"Lidh"</string>
    <string name="bluetooth_connect_confirm" msgid="4769958536295137386">"Lidhe me %1$s"</string>
    <string name="bluetooth_disconnect_action_title" msgid="1135513009197728480">"Shkëput"</string>
    <string name="bluetooth_disconnect_confirm" msgid="1445977623973613581">"Shkëpute nga %1$s"</string>
    <string name="bluetooth_rename_action_title" msgid="4200419902722729907">"Riemërto"</string>
    <string name="bluetooth_rename" msgid="7791922876280337194">"Riemërto pajisjen tënde të lidhur"</string>
    <string name="bluetooth_forget_action_title" msgid="2351140076684719196">"Harro"</string>
    <string name="bluetooth_forget_confirm" msgid="5175414848391021666">"Harro %1$s"</string>
    <string name="bluetooth_serial_number_label" msgid="6639294603220209971">"Adresa e Bluetooth-it"</string>
    <string name="bluetooth_connected_status" msgid="8629393539370085418">"Lidhur"</string>
    <string name="bluetooth_disconnected_status" msgid="7617866963193224775">"Shkëputur"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="1610743588460010736">"Nuk ke leje për të ndryshuar cilësimet e \"Bluetooth-it\"."</string>
    <string name="bluetooth_toggle_active_audio_output_title" msgid="3715722506642793944">"Përdor për audion e televizorit"</string>
    <string name="send_feedback" msgid="936698637869795473">"Dërgo koment"</string>
    <string name="launch_help" msgid="2607478763131952469">"Qendra e ndihmës"</string>
    <string name="system_cast" msgid="6081391679828510058">"Google Cast"</string>
    <string name="system_date_time" msgid="5922833592234018667">"Data dhe ora"</string>
    <string name="system_language" msgid="5516099388471974346">"Gjuha"</string>
    <string name="language_empty_list_user_restricted" msgid="5430199913998605436">"Nuk ke leje të ndryshosh gjuhën e pajisjes."</string>
    <string name="system_keyboard" msgid="1514460705385401872">"Tastiera"</string>
    <string name="system_keyboard_autofill" msgid="8530944165814838255">"Tastiera dhe plotësimi automatik"</string>
    <string name="system_autofill" msgid="6983989261108020046">"Plotësim automatik"</string>
    <string name="system_home" msgid="2149349845791104094">"Ekrani bazë"</string>
    <string name="system_search" msgid="3170169128257586925">"Kërko"</string>
    <string name="system_google" msgid="945985164023885276">"Google"</string>
    <string name="system_security" msgid="1012999639810957132">"Siguria dhe kufizimet"</string>
    <string name="system_speech" msgid="8779582280374089518">"Ligjërimi"</string>
    <string name="system_inputs" msgid="5552840337357572096">"Hyrjet"</string>
    <string name="system_inputs_devices" msgid="2158421111699829399">"Hyrjet dhe pajisjet"</string>
    <string name="system_home_theater_control" msgid="6228949628173590310">"Kontrolli i kinemasë së shtëpisë"</string>
    <string name="system_developer_options" msgid="8480844257066475479">"Opsionet e zhvilluesit"</string>
    <string name="accessibility_none" msgid="6355646833528306702">"Asnjë"</string>
    <string name="system_diagnostic" msgid="1654842813331919958">"Përdorimi dhe diagnostikimi"</string>
    <string name="no_device_admins" msgid="4628974717150185625">"Nuk ka asnjë aplikacion të administrimit të pajisjes në dispozicion"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="7678529948487939871">"Çaktivizuar nga administratori"</string>
    <string name="disabled_by_administrator_summary" msgid="3420979957115426764">"Nuk ofrohet"</string>
    <string name="manage_device_admin" msgid="5714217234035017983">"Apl. e admin. të pajisjes"</string>
    <string name="number_of_device_admins_none" msgid="2734299122299837459">"Asnjë aplikacion aktiv"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="108190334043671416">"Çaktivizuar nga administratori, politika e enkriptimit ose hapësira ruajtëse e kredencialeve"</string>
    <string name="enterprise_privacy_settings" msgid="8226765895133003202">"Informacioni i pajisjes së menaxhuar"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5719549523275019419">"Ndryshimet dhe cilësimet menaxhohen nga organizata jote"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="2866704039759872293">"Ndryshimet dhe cilësimet menaxhohen nga <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="9221881402582661521">"Për të ofruar qasjen në të dhënat e tua të punës, organizata jote mund të ndryshojë cilësimet dhe të instalojë softuerë në pajisjen tënde.\n\nKontakto me administratorin e organizatës për më shumë detaje."</string>
    <string name="enterprise_privacy_exposure_category" msgid="1555735251238636669">"Llojet e informacionit që mund të shikojë organizata jote"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="7750498604032318318">"Ndryshimet e kryera nga administratori i organizatës tënde"</string>
    <string name="enterprise_privacy_device_access_category" msgid="7397106369136259850">"Qasja jote në këtë pajisje"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="8135491104894522008">"Të dhënat e lidhura me llogarinë tënde të punës, si email-i dhe kalendari"</string>
    <string name="enterprise_privacy_installed_packages" msgid="5012554762299490994">"Lista e aplikacioneve në pajisjen tënde"</string>
    <string name="enterprise_privacy_usage_stats" msgid="7062422823174345793">"Sasia e kohës dhe të dhënat e harxhuara në çdo aplikacion"</string>
    <string name="enterprise_privacy_network_logs" msgid="305782312671493780">"Regjistri më i fundit i trafikut të rrjetit"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2393617117911211486">"Raporti më i fundit i defekteve në kod"</string>
    <string name="enterprise_privacy_security_logs" msgid="2573545327989145361">"Regjistri yt më i fundit i sigurisë"</string>
    <string name="enterprise_privacy_none" msgid="6660670916934417519">"Asnjë"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="7244796629052581085">"Aplikacione të instaluara"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="3875568975752197381">"Numri i aplikacioneve është i përafërt. Ai mund të mos përfshijë aplikacionet e instaluara jashtë \"Dyqanit të Play\"."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="4518330667109848939">"{count,plural, =1{Minimumi # aplikacion}other{Minimumi # aplikacione}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8978502415647245748">"Lejet e vendndodhjes"</string>
    <string name="enterprise_privacy_microphone_access" msgid="3746238027890585248">"Lejet e mikrofonit"</string>
    <string name="enterprise_privacy_camera_access" msgid="6258493631976121930">"Lejet e kamerës"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="5538330175901952288">"Apl. e parazgjedhura"</string>
    <string name="enterprise_privacy_number_packages" msgid="6256222390430349008">"{count,plural, =1{# aplikacion}other{# aplikacione}}"</string>
    <string name="enterprise_privacy_input_method" msgid="5814752394251833058">"Tastiera e parazgjedhur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="1088874503312671318">"Caktuar në <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="8845550514448914237">"Rrjeti VPN gjithmonë aktiv i aktivizuar"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="6996782365866442280">"Rrjeti VPN gjithmonë aktiv i aktivizuar në profilin tënd personal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="3674119583050531071">"Rrjeti VPN gjithmonë aktiv i aktivizuar në profilin tënd të punës"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="2818848848337527780">"Proxy global HTTP i caktuar"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="975646846291012452">"Kredencialet e besuara"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="7641368559306519707">"Kredencialet e besuara në profilin tënd personal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="2905939250974399645">"Kredencialet e besuara në profilin tënd të punës"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="5918439861975410142">"{count,plural, =1{# certifikatë CA}other{# certifikata CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="3140624232334033641">"Administratori mund ta kyçë pajisjen dhe rivendosë fjalëkalimin"</string>
    <string name="enterprise_privacy_wipe_device" msgid="1714271125636510031">"Administratori mund të fshijë të gjitha të dhënat e pajisjes"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="8272298134556250600">"Përpjekje të dështuara për fjalëkalimin përpara se të fshihen të gjitha të dhënat e pajisjes"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="1184137458404844014">"Përpjekje të dështuara për fjalëkalimin përpara se të fshihen të dhënat e profilit të punës"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="277415009661470768">"{count,plural, =1{# përpjekje}other{# përpjekje}}"</string>
    <string name="do_disclosure_generic" msgid="8390478119591845948">"Kjo pajisje menaxhohet nga organizata jote."</string>
    <string name="do_disclosure_with_name" msgid="4755509039938948975">"Kjo pajisje menaxhohet nga <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="4226390963162716446">" "</string>
    <string name="hdr_capability" msgid="3331021013422460270">"- %1$s"</string>
    <string name="learn_more" msgid="820336467414665686">"Mëso më shumë"</string>
    <string name="default_camera_app_title" msgid="4573905807226306484">"{count,plural, =1{Aplikacioni i kamerës}other{Aplikacionet e kamerës}}"</string>
    <string name="default_calendar_app_title" msgid="1533912443930743532">"Aplikacioni i kalendarit"</string>
    <string name="default_contacts_app_title" msgid="7792041146751261191">"Aplikacioni i kontakteve"</string>
    <string name="default_email_app_title" msgid="3712283056326496555">"{count,plural, =1{App i klientit të email-it}other{App të klientit të email-it}}"</string>
    <string name="default_map_app_title" msgid="9051013257374474801">"Aplikacioni i hartës"</string>
    <string name="default_phone_app_title" msgid="4833449131501871644">"{count,plural, =1{Aplikacioni i telefonatave}other{Aplikacionet e telefonatave}}"</string>
    <string name="default_browser_title" msgid="3612813200586492159">"Aplikacioni i shfletuesit"</string>
    <string name="app_names_concatenation_template_2" msgid="5297284354915830297">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="4932774380339466733">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="tutorials" msgid="7880770425872110455">"Udhëzime"</string>
    <string name="about_system_update" msgid="7421264399111367755">"Përditësimi i sistemit"</string>
    <string name="system_update_description" msgid="998883510488461766">"Kjo do ta rivendosë softuerin e sistemit tënd në versionin më të fundit. Pajisja jote do të riniset."</string>
    <string name="system_update_content_description" msgid="5702888187682876466">"\"Përditësimi i sistemit\", kjo do ta rivendosë softuerin e sistemit tënd në versionin më të fundit. Pajisja jote do të riniset."</string>
    <string name="about_preference" msgid="9112690446998150670">"Informacion"</string>
    <string name="device_name" msgid="566626587332817733">"Emri i pajisjes"</string>
    <string name="restart_button_label" msgid="911750765086382990">"Rinis"</string>
    <string name="about_legal_info" msgid="2148797328415559733">"Informacioni ligjor"</string>
    <string name="about_legal_license" msgid="4056934178111674054">"Kodi burimor nga një palë e tretë"</string>
    <string name="about_terms_of_service" msgid="8514826341101557623">"Informacioni ligjor i Google"</string>
    <string name="about_license_activity_unavailable" msgid="4559187037375581674">"Të dhënat e licencës nuk ofrohen"</string>
    <string name="about_model" msgid="9164284529291439296">"Modeli"</string>
    <string name="device_mode" msgid="7258350575590118152">"Modaliteti i pajisjes"</string>
    <string name="store_demo_mode" msgid="4382231515659362796">"Demonstrimi i dyqanit"</string>
    <string name="about_version" msgid="6223547403835399861">"Versioni i sistemit operativ të Android TV"</string>
    <string name="about_serial" msgid="3432319328808745459">"Numri i serisë"</string>
    <string name="about_build" msgid="8467840394761634575">"Ndërtimi i sistemit operativ të Android TV"</string>
    <string name="show_dev_countdown" msgid="4064986225625409361">"{count,plural, =1{Tani të duhet edhe # hap që të bëhesh zhvillues}other{Tani të duhen edhe # hapa që të bëhesh zhvillues}}"</string>
    <string name="about_ads" msgid="7662896442040086522">"Reklamat"</string>
    <string name="ads_description" msgid="8081069475265061074">"Menaxho cilësimet e reklamave, si rivendosjen e ID-së sate reklamuese."</string>
    <string name="ads_content_description" msgid="1006489792324920289">"\"Reklamat\", menaxho cilësimet e reklamave, si rivendosjen e ID-së sate reklamuese."</string>
    <string name="show_dev_on" msgid="612741433124106067">"Tani je zhvillues!"</string>
    <string name="show_dev_already" msgid="1522591284776449818">"Nuk ka nevojë, ti je tashmë një zhvillues"</string>
    <string name="device_info_default" msgid="2374506935205518448">"E panjohur"</string>
    <string name="selinux_status" msgid="1146662734953021410">"Statusi i SELinux"</string>
    <string name="selinux_status_disabled" msgid="4027105362332795142">"Çaktivizuar"</string>
    <string name="selinux_status_permissive" msgid="8694617578567517527">"Tolerant"</string>
    <string name="selinux_status_enforcing" msgid="4140979635669643342">"Detyrues"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="1839534735929143986">"Përditësime shtesë të sistemit"</string>
    <string name="ssl_ca_cert_warning" msgid="7836390021162211069">"Rrjeti mund të jetë i monitoruar"</string>
    <string name="done_button" msgid="616159688526431451">"U krye"</string>
    <string name="sl_ca_cert_dialog_title" msgid="5104377991202801698">"{count,plural, =1{Besoje ose hiqe certifikatën}other{Besoji ose hiqi certifikatat}}"</string>
    <string name="device_status" msgid="8266002761193692207">"Statusi"</string>
    <string name="device_status_summary" msgid="3270932829412434985">"Rrjeti, numrat e serisë dhe informacione të tjera"</string>
    <string name="manual" msgid="5683935624321864999">"Manuale"</string>
    <string name="regulatory_information" msgid="9107675969694713391">"Informacione rregullatore"</string>
    <string name="device_feedback" msgid="4871903271442960465">"Dërgo komentet për këtë pajisje"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4641790432171693921">"Ngarkuesi i sistemit është i shkyçur tashmë"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="2979556699380115576">"Lidhu me internetin fillimisht"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="1946089732305102622">"Lidhu me internetin ose kontakto me operatorin celular"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="5634005787486307657">"Nuk ofrohet në pajisjet e kyçura për një operator celular"</string>
    <string name="oem_lock_info_message" msgid="2165887409937351689">"Rinis pajisjen për të aktivizuar funksionin e mbrojtjes së pajisjes."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="1654574152815129396">"<xliff:g id="SIZE">%1$s</xliff:g> në total të bëra të disponueshme\n\nEkzekutimi i fundit në datën <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="fcc_equipment_id" msgid="6731077083927000108">"ID-ja e pajisjes"</string>
    <string name="baseband_version" msgid="5618116741093274294">"Versioni i brezit të bazës"</string>
    <string name="kernel_version" msgid="7265509054070001542">"Versioni i bërthamës"</string>
    <string name="status_unavailable" msgid="2033933928980193334">"I padisponueshëm"</string>
    <string name="device_status_title" msgid="9051569510258883673">"Statusi"</string>
    <string name="battery_status_title" msgid="8850166742025222210">"Statusi i baterisë"</string>
    <string name="battery_level_title" msgid="2672804570916248736">"Niveli i baterisë"</string>
    <string name="status_bt_address" msgid="7190052214963950844">"Adresa e Bluetooth-it"</string>
    <string name="status_up_time" msgid="1758102680983108313">"Koha aktive"</string>
    <string name="legal_information" msgid="1087445528481370874">"Informacioni ligjor"</string>
    <string name="copyright_title" msgid="5879660711078649518">"Të drejtat e autorit"</string>
    <string name="license_title" msgid="4032466200355435641">"Licenca"</string>
    <string name="terms_title" msgid="192888187310800678">"Kushtet e përgjithshme"</string>
    <string name="webview_license_title" msgid="5370270485188947540">"Licenca e WebView në sistem"</string>
    <string name="consumer_information_title" msgid="7729729568416672733">"Informacione për konsumatorët"</string>
    <string name="consumer_information_message" msgid="205236637689468764">"Përmbajtjet që gjen në Android TV vijnë nga partnerë palë të treta, si p.sh. zhvillues aplikacionesh dhe studio filmash, si dhe nga vetë Google. Për më shumë informacione, shiko "<a href="g.co/tv/androidtvinfo">"g.co/tv/androidtvinfo"</a></string>
    <string name="consumer_information_button_ok" msgid="6979480064600038080">"Në rregull"</string>
  <string-array name="wifi_signal_strength">
    <item msgid="4475363344103354364">"I dobët"</item>
    <item msgid="2098818614362343532">"Pak i dobët"</item>
    <item msgid="2713050260700175954">"I mirë"</item>
    <item msgid="6005053494500517261">"I shkëlqyer"</item>
  </string-array>
    <string name="title_mac_address" msgid="7511588678922209883">"Adresa MAC e pajisjes"</string>
    <string name="title_randomized_mac_address" msgid="3359532498635833471">"Adresa MAC e rastësishme"</string>
    <string name="title_signal_strength" msgid="5047116893338315998">"Fuqia e sinjalit"</string>
    <string name="title_random_mac_settings" msgid="6685812569356353378">"Privatësia"</string>
  <string-array name="random_mac_settings_entries">
    <item msgid="3457228452595715533">"Përdor adresë MAC të rastësishme (parazgjedhje)"</item>
    <item msgid="2490415280467390067">"Përdor adresën MAC të pajisjes"</item>
  </string-array>
    <string name="mac_address_not_available" msgid="2992935344891853369">"Nuk ofrohet"</string>
    <string name="mac_address_ephemeral_summary" msgid="3284374877361772531">"Adresa MAC e rastësishme"</string>
    <string name="title_ip_address" msgid="705842159484772807">"Adresa e IP-së"</string>
    <string name="title_ssid" msgid="255328048344188682">"Fut emrin e rrjetit Wi-Fi"</string>
    <string name="title_internet_connection" msgid="7502414094881828069">"Lidhje me internetin"</string>
    <string name="connected" msgid="4981532275162345997">"U lidh"</string>
    <string name="not_connected" msgid="475810896484271663">"Nuk është lidhur"</string>
    <string name="wifi_no_internet" msgid="27421689535934864">"Nuk ka internet"</string>
    <string name="wifi_saved" msgid="4354792774811431829">"U ruajt"</string>
    <string name="wifi_bad_password" msgid="8686375382346768922">"Fjalëkalim i gabuar"</string>
    <string name="wifi_short_password" msgid="7658809378390032385">"Fjalëkalimi i Wi-Fi është shumë i shkurtër"</string>
    <string name="wifi_captive_portal" msgid="8262150024660339529">"Kërkohet identifikimi"</string>
    <string name="wifi_setting_header_other_options" msgid="217382325707026836">"Opsione të tjera..."</string>
    <string name="wifi_setting_see_all" msgid="5048103047976316675">"Shiko të gjitha"</string>
    <string name="wifi_setting_see_fewer" msgid="8585364493300703467">"Shiko më pak"</string>
    <string name="wifi_setting_available_networks" msgid="2096957819727319750">"Rrjetet në dispozicion"</string>
    <string name="wifi_setting_other_options_add_network" msgid="6490215784178866978">"Shto një rrjet të ri"</string>
    <string name="wifi_setting_other_options_add_network_via_easyconnect" msgid="2869989555950644533">"Lidhja e shpejtë"</string>
    <string name="wifi_setting_other_options_add_network_via_easyconnect_info_summary" msgid="4564538591168691865">"Lidhja e shpejtë të ndihmon të lidhesh me shpejtësi me rrjetin tënd Wi-Fi duke skanuar kodin QR në telefonin tënd."</string>
    <string name="security_type" msgid="2297615092250075696">"Lloji i sigurisë"</string>
    <string name="other_network" msgid="5299289104661858596">"Rrjet tjetër…"</string>
    <string name="skip_network" msgid="3095529090560000692">"Kapërce"</string>
    <string name="wifi_security_type_none" msgid="7001835819813531253">"Asnjë"</string>
    <string name="wifi_security_type_wep" msgid="6407712450924151962">"WEP"</string>
    <string name="wifi_security_type_wpa" msgid="9205358644485448199">"WPA/WPA2 PSK"</string>
    <string name="wifi_security_type_eap" msgid="3948280751219829163">"802.1x EAP"</string>
    <string name="title_wifi_no_networks_available" msgid="3696700321170616981">"Po skanon..."</string>
    <string name="title_wifi_could_not_save" msgid="7549912968719395764">"Konfigurimi për <xliff:g id="SSID">%1$s</xliff:g> nuk mund të ruhej"</string>
    <string name="title_wifi_could_not_connect" msgid="6654031057635481872">"Nuk mund të lidhej me <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="title_wifi_could_not_connect_timeout" msgid="7825788623604214601">"<xliff:g id="SSID">%1$s</xliff:g> nuk mund të gjendej"</string>
    <string name="title_wifi_could_not_connect_authentication_failure" msgid="6626386897327862432">"Fjalëkalimi i Wi-Fi nuk është i vlefshëm"</string>
    <string name="title_wifi_could_not_connect_ap_reject" msgid="5182833781690447828">"Rrjeti Wi-Fi nuk e pranoi lidhjen"</string>
    <string name="title_wifi_advanced_options" msgid="371185991282743258">"Të konfigurohen proxy <xliff:g id="SSID">%1$s</xliff:g> dhe cilësimet e IP-së?"</string>
    <string name="title_wifi_proxy_settings" msgid="1933444342984660569">"Cilësimet e proxy-it"</string>
    <string name="title_wifi_proxy_hostname" msgid="1242297002220870385">"Emri pritës i proxy-it:"</string>
    <string name="title_wifi_proxy_port" msgid="566244407030390328">"Porta e proxy-it:"</string>
    <string name="title_wifi_proxy_bypass" msgid="8752756240663231435">"Anashkalo proxy-in për:"</string>
    <string name="title_wifi_ip_settings" msgid="296029383749112888">"Cilësimet e IP-së"</string>
    <string name="title_wifi_ip_address" msgid="5505806431042689276">"Adresa IP:"</string>
    <string name="title_wifi_gateway" msgid="4496416267930824360">"Porta e kalimit:"</string>
    <string name="title_wifi_network_prefix_length" msgid="3200370297772096824">"Gjatësia e prefiksit të rrjetit:"</string>
    <string name="title_wifi_dns1" msgid="1585965227665007553">"DNS 1:"</string>
    <string name="title_wifi_dns2" msgid="4563319371301555072">"DNS 2:"</string>
    <string name="title_wifi_proxy_settings_invalid" msgid="7698883245005941665">"Cilësimet e proxy-it nuk janë të vlefshme"</string>
    <string name="title_wifi_ip_settings_invalid" msgid="7283801973512992014">"Cilësimet e IP-së nuk janë të vlefshme"</string>
    <string name="title_wifi_known_network" msgid="6162483884727898697">"<xliff:g id="SSID">%1$s</xliff:g> është një rrjet i ruajtur"</string>
    <string name="title_wifi_scan_qr_code" msgid="7485605625055717874">"Skano kodin QR për t\'u bashkuar"</string>
    <string name="wifi_action_try_again" msgid="8920677153891141148">"Provo përsëri"</string>
    <string name="wifi_action_view_available_networks" msgid="609561604257828342">"Shiko rrjetet në dispozicion"</string>
    <string name="wifi_connecting" msgid="4234341255109283018">"Po lidhet me <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_saving" msgid="320653339670641708">"Po ruhet konfigurimi për <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_connect" msgid="2206086690065242121">"Lidh"</string>
    <string name="wifi_forget_network" msgid="4634016112624305571">"Harroje rrjetin"</string>
    <string name="wifi_forget_network_description" msgid="4146715475962713899">"Kjo pastron informacionet e përdorura për t\'u lidhur me këtë rrjet, duke përfshirë një fjalëkalim të ruajtur"</string>
    <string name="wifi_scan_qr_code_description" msgid="6620444691131671132">" Bashkohu me një rrjet Wi-Fi duke skanuar kodin QR nga një telefon celular dhe ndiq udhëzimet.\n \n Nga "<b>"një telefon Android"</b>", shko te Cilësimet -&gt; Rrjeti dhe interneti -&gt; Wi-Fi -&gt; Zgjidh një rrjet Wi-Fi -&gt; Të përparuara -&gt; Shto një pajisje dhe më pas skano kodin QR."</string>
    <string name="wifi_scan_qr_code_back_description" msgid="8830716278283379280">"Shtyp butonin \"Prapa\" për ta anuluar"</string>
    <string name="wifi_action_ok" msgid="6257483288047397880">"Në rregull"</string>
    <string name="wifi_setup_action_dont_change_network" msgid="2999582059217623090">"Vazhdo"</string>
    <string name="wifi_setup_action_change_network" msgid="1603908238711710943">"Ndrysho rrjetin"</string>
    <string name="wifi_action_change_network" msgid="3943123581726966199">"Ndrysho"</string>
    <string name="wifi_action_dont_change_network" msgid="2685585142299769847">"Mos ndrysho"</string>
    <string name="wifi_action_advanced_yes" msgid="6192652088198093438">"Në rregull"</string>
    <string name="wifi_action_advanced_no" msgid="6152107256122343959">"Jo (rekomandohet)"</string>
    <string name="wifi_action_proxy_none" msgid="4009573120495700922">"Asnjë"</string>
    <string name="wifi_action_proxy_manual" msgid="7667686394955896293">"Manuale"</string>
    <string name="wifi_action_dhcp" msgid="6172127495589802964">"DHCP"</string>
    <string name="wifi_action_static" msgid="8139559358727790887">"Statike"</string>
    <string name="wifi_action_status_info" msgid="3947061894001350963">"Informacionet e statusit"</string>
    <string name="wifi_action_advanced_options_title" msgid="2863126553877147921">"Opsionet e përparuara"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="4051342269154914595">"Fut një adresë të vlefshme të IP-së"</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="4511579679784872130">"Fut një adresë të vlefshme të portës së kalimit"</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="5111100342560120360">"Fut një adresë të vlefshme të DNS-së"</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="2726889303835927777">"Fut një gjatësi prefiksi të rrjetit nga 0 deri në 32"</string>
    <string name="wifi_ip_address_description" msgid="7109677764979198618">"Fut një adresë të vlefshme të IP-së.\nShembull: <xliff:g id="ID_1">192.168.1.128</xliff:g>"</string>
    <string name="wifi_dns1_description" msgid="2287252520192279195">"Fut një adresë të vlefshme të IP-së ose lëre bosh.\nShembull: <xliff:g id="ID_1">8.8.8.8</xliff:g>"</string>
    <string name="wifi_dns2_description" msgid="6495565714252833784">"Fut një adresë të vlefshme IP-je ose lëre bosh.\nShembull: <xliff:g id="ID_1">8.8.4.4</xliff:g>"</string>
    <string name="wifi_gateway_description" msgid="8902481147103929271">"Fut një adresë të vlefshme të IP-së ose lëre bosh.\nShembull: <xliff:g id="ID_1">192.168.1.1</xliff:g>"</string>
    <string name="wifi_network_prefix_length_description" msgid="2670994968279018896">"Fut një gjatësi të vlefshme prefiksi rrjeti.\nShembull: <xliff:g id="ID_1">24</xliff:g>"</string>
    <string name="proxy_error_invalid_host" msgid="5629893736174170157">"Emri i strehuesit nuk është i vlefshëm"</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="1762079966901078116">"Kjo listë përjashtimesh nuk është e vlefshme. Fut një listë të ndarë me presje për domenet e përjashtuara."</string>
    <string name="proxy_error_empty_port" msgid="692020249267351015">"Fusha e portës nuk mund të jetë bosh"</string>
    <string name="proxy_error_empty_host_set_port" msgid="5347712018244852847">"Nëse fusha e strehuesit është bosh, lëre bosh fushën e portës"</string>
    <string name="proxy_error_invalid_port" msgid="5307010810664745294">"Porta nuk është e vlefshme"</string>
    <string name="proxy_warning_limited_support" msgid="4220553563487968684">"Proxy i HTTP-së përdoret nga shfletuesi, por nuk mund të përdoret nga aplikacionet e tjera"</string>
    <string name="proxy_port_description" msgid="6486205863098427787">"Fut një portë të vlefshme.\nShembull: <xliff:g id="ID_1">8080</xliff:g>"</string>
    <string name="proxy_exclusionlist_description" msgid="5105504899364188296">"Fut një listë të ndarë me presje për domenet e përjashtuara ose lëre bosh.\nShembull: <xliff:g id="ID_1">example.com,mycomp.test.com,localhost</xliff:g>"</string>
    <string name="proxy_hostname_description" msgid="5520200112290557199">"Fut një emër të vlefshëm të strehuesit.\nShembull: <xliff:g id="ID_1">proxy.example.com</xliff:g>"</string>
    <string name="title_wifi_eap_method" msgid="4351752615786996226">"Zgjidh metodën EAP për <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="title_wifi_phase2_authentication" msgid="1167205033305931574">"Zgjidh vërtetimin phase2 për <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="title_wifi_identity" msgid="6273917200971028259">"Vendos identitetin për <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="title_wifi_anonymous_identity" msgid="5965175781722004334">"Vendos identitetin anonim për <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_setup_summary_title_connected" msgid="2725439590655448489">"Je lidhur me <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_summary_title_connected" msgid="201105022065577659">"Rrjeti u lidh"</string>
    <string name="wifi_summary_title_not_connected" msgid="7991004795297065201">"Rrjeti nuk është lidhur"</string>
    <string name="wifi_summary_description_connected_to_wifi_network" msgid="8796747274977762311">"Është lidhur tashmë me <xliff:g id="SSID">%1$s</xliff:g>. Të lidhet me një rrjet tjetër?"</string>
    <string name="wifi_summary_unknown_network" msgid="8044143986439139664">"një rrjet i panjohur"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7326314737931342236">"Nuk ke leje të ndryshosh rrjetin Wi-Fi."</string>
    <string name="title_ok" msgid="6500452958848127145">"Në rregull"</string>
    <string name="title_cancel" msgid="2337143367016419016">"Anulo"</string>
    <string name="storage_title" msgid="6637715914885228193">"Hapësira ruajtëse"</string>
    <string name="storage_available" msgid="8860901789290434209">"Në dispozicion"</string>
    <string name="storage_size" msgid="5517261387579171381">"Hapësira në total: <xliff:g id="TOTAL_SPACE">%1$s</xliff:g>"</string>
    <string name="storage_calculating_size" msgid="5716281278843281044">"Po llogaritet…"</string>
    <string name="storage_apps_usage" msgid="8659915575274468924">"Aplikacionet"</string>
    <string name="storage_downloads_usage" msgid="8429196848359517158">"Shkarkimet"</string>
    <string name="storage_dcim_usage" msgid="1890098882753254745">"Fotografitë dhe videot"</string>
    <string name="storage_music_usage" msgid="5362871290115089474">"Audio"</string>
    <string name="storage_media_misc_usage" msgid="3404230292054880339">"Të ndryshme"</string>
    <string name="storage_media_cache_usage" msgid="6397941751551207630">"Të dhënat e memories specifike"</string>
    <string name="storage_eject" msgid="3268870873944951902">"Nxirr"</string>
    <string name="storage_format" msgid="5360900929128087085">"Spastro dhe formato"</string>
    <string name="storage_format_as_private" msgid="77945551149326052">"Spastro dhe formato si hapësirë ruajtëse të pajisjes"</string>
    <string name="storage_format_as_public" msgid="6745112917895223463">"Spastro dhe formato si hapësirë ruajtëse të lëvizshme"</string>
    <string name="storage_format_for_private" msgid="5380138334184923252">"Formato si hapësirë ruajtëse të pajisjes"</string>
    <string name="storage_not_connected" msgid="4327902652748552794">"Nuk është lidhur"</string>
    <string name="storage_migrate" msgid="9137556600192167701">"Migro të dhënat te kjo hapësirë ruajtëse"</string>
    <string name="storage_migrate_away" msgid="7880100961434638430">"Migro të dhënat te një hapësirë tjetër ruajtjeje"</string>
    <string name="storage_no_apps" msgid="95566375753627272">"Nuk ka aplikacione për të rezervuar"</string>
    <string name="storage_forget" msgid="4671975563260507003">"Harroje hapësirën ruajtëse të kësaj pajisjeje"</string>
    <string name="storage_forget_wall_of_text" msgid="230454348256179142">"Për të përdorur aplikacionet ose të dhënat që përmban kjo njësi disku, lidhe atë përsëri. Si alternativë, mund të zgjedhësh që ta harrosh këtë hapësirë ruajtëse nëse njësia e diskut nuk është e disponueshme.\n\nNëse zgjedh \"Harro\", të gjitha të dhënat që përmban njësia e diskut do të humbasin përgjithmonë.\n\nMund t\'i instalosh përsëri më vonë aplikacionet, por të dhënat e ruajtura në këtë njësi disku do të humbasin."</string>
    <string name="storage_device_storage_section" msgid="22958375769694027">"Hapësira ruajtëse e pajisjes"</string>
    <string name="storage_removable_storage_section" msgid="280332107650735088">"Hapësira ruajtëse e lëvizshme"</string>
    <string name="storage_reset_section" msgid="3896575204828589494">"Rivendos"</string>
    <string name="storage_free_up" msgid="5719667150891467122">"Liro hapësirën ruajtëse"</string>
    <string name="storage_free_up_clear_cached_data" msgid="858596875459698634">"Pastro të dhënat e memories specifike"</string>
    <string name="storage_free_up_clear_cached_data_summary" msgid="3111860361699185304">"Liro <xliff:g id="SPACE">%1$s</xliff:g>"</string>
    <string name="storage_free_up_clear_cached_data_info" msgid="719348815620748812">"Pastron skedarët e përkohshëm që zënë hapësirë. Të dhënat e ruajtura si preferencat e aplikacioneve apo videot offline nuk do të ndikohen dhe nuk do të të duhet të identifikohesh më në aplikacione."</string>
    <string name="storage_free_up_clear_cached_data_confirm_title" msgid="5047418718048910850">"Të pastrohen të dhënat e memories specifike?"</string>
    <string name="storage_free_up_clear_cached_data_confirm_description" msgid="4840728913914074729">"Pastron memorien specifike për aplikacionet."</string>
    <string name="storage_free_up_uninstall_apps" msgid="7755671754934975908">"Çinstalo aplikacione"</string>
    <string name="storage_mount_success" msgid="4459298609971461753">"<xliff:g id="NAME">%1$s</xliff:g> u montua"</string>
    <string name="storage_mount_failure" msgid="8521666906216755903">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të montohej"</string>
    <string name="storage_mount_adopted" msgid="8880688040694403520">"Hapësira ruajtëse USB u lidh përsëri"</string>
    <string name="storage_unmount_success" msgid="8024867595129715661">"<xliff:g id="NAME">%1$s</xliff:g> u nxor në mënyrë të sigurt"</string>
    <string name="storage_unmount_failure" msgid="2228448194484319930">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të nxirrej në mënyrë të sigurt"</string>
    <string name="storage_unmount_failure_cant_find" msgid="2890335341404932068">"Nuk mund të gjendej njësia për t\'u nxjerrë"</string>
    <string name="storage_format_success" msgid="5599914756144012286">"<xliff:g id="NAME">%1$s</xliff:g> është formatuar"</string>
    <string name="storage_format_failure" msgid="5619442934314277332">"<xliff:g id="NAME">%1$s</xliff:g> nuk mund të formatohej"</string>
    <string name="storage_wizard_format_as_private_title" msgid="7985715762649933211">"Formato si hapësirë ruajtëse pajisjeje"</string>
    <string name="storage_wizard_format_as_private_description" msgid="6143406934742456154">"Kjo kërkon që njësia USB të formatohet për ta bërë atë të sigurt. Pas formatimit të sigurt, kjo njësi disku do të funksionojë vetëm me këtë pajisje. Formatimi spastron të gjitha të dhënat e ruajtura aktualisht në njësinë e diskut. Për të shmangur humbjen e të dhënave, ki parasysh që ta rezervosh atë."</string>
    <string name="storage_wizard_format_as_public_title" msgid="3546915348149438389">"Spastro dhe formato"</string>
    <string name="storage_wizard_format_as_public_description" msgid="5849129772499352597">"Pas formatimit, mund ta përdorësh këtë njësi USB në pajisje të tjera. Të gjitha të dhënat do të spastrohen. Ki parasysh ta rezervosh në fillim duke i zhvendosur aplikacionet te një hapësirë ruajtëse tjetër e pajisjes."</string>
    <string name="storage_wizard_format_progress_title" msgid="3875906251546380271">"Njësia USB po formatohet…"</string>
    <string name="storage_wizard_format_progress_description" msgid="292229747129805538">"Kjo mund të zgjasë një çast. Mos e hiq njësinë e diskut."</string>
    <string name="storage_wizard_migrate_choose_title" msgid="8743036821605231654">"Zgjidh hapësirën ruajtëse ku do të migrosh të dhënat"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="5086390005970210697">"Zhvendos të dhënat te <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_wizard_migrate_confirm_description" msgid="918834441157741482">"Zhvendos fotografitë, skedarët dhe të dhënat e aplikacioneve te <xliff:g id="NAME">%1$s</xliff:g>. Kjo mund të zgjasë disa minuta. Disa aplikacione nuk do të funksionojnë si duhet gjatë zhvendosjes."</string>
    <string name="storage_wizard_migrate_confirm_action_move_now" msgid="7512917600174814567">"Zhvendos tani"</string>
    <string name="storage_wizard_migrate_confirm_action_move_later" msgid="6379986754827551474">"Zhvendos më vonë"</string>
    <string name="storage_wizard_migrate_toast_success" msgid="6153579567666607584">"Të dhënat u migruan te <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_wizard_migrate_toast_failure" msgid="8580347235983040966">"Të dhënat nuk mund të migroheshin te <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="2623480667090826800">"Po zhvendos të dhënat te <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="storage_wizard_migrate_progress_description" msgid="4023358325977284145">"Kjo mund të zgjasë një çast. Mos e hiq njësinë e diskut.\nDisa aplikacione nuk do të funksionojnë si duhet gjatë zhvendosjes."</string>
    <string name="storage_wizard_format_slow_title" msgid="7640229918512394316">"Kjo njësi disku duket se është e ngadaltë."</string>
    <string name="storage_wizard_format_slow_summary" msgid="3674023258060474037">"Mund të vazhdosh, por aplikacionet e zhvendosura në këtë vend mund të kenë pengesa dhe transferimi i të dhënave mund të kërkojë një kohë të gjatë. Ki parasysh të përdorësh një njësi disku më të shpejtë për një cilësi më të mirë të funksionimit."</string>
    <string name="storage_wizard_format_action" msgid="3275676687226857170">"Formato"</string>
    <string name="storage_wizard_backup_apps_action" msgid="1402199004931596519">"Rezervo aplikacionet"</string>
    <string name="storage_wizard_back_up_apps_title" msgid="6225663573896846937">"Aplikacionet e ruajtura në <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_wizard_back_up_apps_and_data_title" msgid="7763611380573099978">"Aplikacionet dhe të dhënat e ruajtura në <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_wizard_back_up_apps_space_available" msgid="5741521038349239359">"<xliff:g id="SIZE">%1$s</xliff:g> në dispozicion"</string>
    <string name="storage_wizard_eject_private_title" msgid="1336088625197134497">"Nxirre hapësirën ruajtëse të pajisjes"</string>
    <string name="storage_wizard_eject_private_description" msgid="4341905730016007385">"Aplikacionet në këtë hapësirë ruajtëse të pajisjes nuk do të funksionojnë më kur ajo nxirret. Kjo njësi USB është formatuar që të punojë vetëm në këtë pajisje. Ajo nuk do të punojë në asnjë pajisje tjetër."</string>
    <string name="storage_wizard_eject_progress_title" msgid="6025569356827683446">"<xliff:g id="NAME">%1$s</xliff:g> po nxirret…"</string>
    <string name="storage_wizard_move_app_title" msgid="6504922588346440942">"Hapësira ruajtëse e përdorur"</string>
    <string name="storage_wizard_move_app_progress_title" msgid="7058465372227392453">"<xliff:g id="NAME">%1$s</xliff:g> po zhvendoset…"</string>
    <string name="storage_wizard_move_app_progress_description" msgid="7673347796805764888">"Mos e hiq njësinë e diskut gjatë zhvendosjes.\nAplikacioni <xliff:g id="APPNAME">%1$s</xliff:g> në këtë pajisje nuk do të jetë në dispozicion deri sa të përfundojë zhvendosja."</string>
    <string name="storage_wizard_forget_confirm_title" msgid="3709482471888830896">"Dëshiron ta harrosh hapësirën ruajtëse të pajisjes?"</string>
    <string name="storage_wizard_forget_confirm_description" msgid="5896860042525566767">"Të gjitha të dhënat e ruajtura në këtë njësi disku do të humbasin përgjithmonë me \"Harro\". Dëshiron që të vazhdosh?"</string>
    <string name="storage_wizard_forget_action" msgid="5609631662522950596">"Harro"</string>
    <string name="storage_new_title" msgid="4768955281180255038">"Njësia USB u lidh"</string>
    <string name="storage_new_action_browse" msgid="3355241742574072658">"Shfleto"</string>
    <string name="storage_new_action_adopt" msgid="6809707961170895964">"Konfiguro si hapësirë ruajtëse të pajisjes"</string>
    <string name="storage_new_action_format_public" msgid="1964662216574764811">"Konfiguro si hapësirë ruajtëse të lëvizshme"</string>
    <string name="storage_new_action_eject" msgid="919249291814300000">"Nxirr"</string>
    <string name="storage_missing_title" msgid="9068915586235805818">"<xliff:g id="NAME">%1$s</xliff:g> u hoq"</string>
    <string name="storage_missing_description" msgid="6835620703133204249">"Disa aplikacione nuk do të jenë në dispozicion ose nuk do të funksionojnë si duhet deri sa njësia e diskut të lidhet përsëri."</string>
    <string name="insufficient_storage" msgid="4175940286022466535">"Nuk ka hapësirë ruajtëse të mjaftueshme."</string>
    <string name="does_not_exist" msgid="4071082040759146781">"Aplikacioni nuk ekziston."</string>
    <string name="invalid_location" msgid="5571789982293787489">"Vendndodhja e instalimit nuk është e vlefshme."</string>
    <string name="system_package" msgid="8276098460517049146">"Përditësimet e sistemit nuk mund të instalohen në median e jashtme."</string>
    <string name="move_error_device_admin" msgid="4144472536756635173">"Administratori i pajisjes nuk mund të instalohet në pajisje të jashtme."</string>
    <string name="learn_more_action" msgid="7972102006620925604">"Mëso më shumë"</string>
    <string name="system_date" msgid="2503462662633178207">"Data"</string>
    <string name="system_time" msgid="8434726081412227535">"Ora"</string>
    <string name="system_set_date" msgid="5815123588301469720">"Vendos datën"</string>
    <string name="system_set_time" msgid="7179243042276057341">"Vendos orën"</string>
    <string name="system_set_time_zone" msgid="6471564469883225195">"Cakto brezin orar"</string>
    <string name="desc_set_time_zone" msgid="4926392006501180047">"<xliff:g id="OFFSET">%1$s</xliff:g>, <xliff:g id="NAME">%2$s</xliff:g>"</string>
    <string name="system_set_time_format" msgid="902518158066450918">"Përdor formatin 24-orësh"</string>
    <string name="desc_set_time_format" msgid="8688587526768572230">"<xliff:g id="STATE">%1$s</xliff:g> (<xliff:g id="SAMPLE">%2$s</xliff:g>)"</string>
    <string name="system_auto_date_time" msgid="8458199433555868708">"Data dhe ora automatike"</string>
  <string-array name="auto_date_time_entries">
    <item msgid="8119837829162871025">"Përdor orën e ofruar nga rrjeti"</item>
    <item msgid="369146066143710034">"Joaktive"</item>
  </string-array>
  <string-array name="auto_date_time_ts_entries">
    <item msgid="1010003447137304123">"Përdor orën e ofruar nga rrjeti"</item>
    <item msgid="5645263357181875427">"Përdor orën e ofruar nga transmetimi i transportit"</item>
    <item msgid="5501503537181350884">"Joaktive"</item>
  </string-array>
    <string name="sensor_toggle_description" msgid="7415801459994303159">"Për të gjitha aplikacionet dhe shërbimet"</string>
    <string name="recently_accessed_by_category" msgid="6841705864715653428">"Qasjet së fundi nga"</string>
    <string name="no_recent_sensor_accesses" msgid="3498112970658050800">"Nuk ka pasur qasje së fundi"</string>
    <string name="recently_accessed_show_all" msgid="5234849189704717855">"Shiko të gjitha"</string>
    <string name="microphone" msgid="7893752847683941214">"Mikrofoni"</string>
    <string name="mic_toggle_title" msgid="7193417007060235665">"Qasja te mikrofoni"</string>
    <string name="mic_remote_toggle_title" msgid="7153283895012570080">"Qasja e mikrofonit në telekomandë"</string>
    <string name="open_mic_permissions" msgid="8121871594807641073">"Qasja e aplikacionit te mikrofoni"</string>
    <string name="microphone_physical_privacy_enabled_title" msgid="6135130916399886772">"Qasja te mikrofoni u bllokua"</string>
    <string name="microphone_physical_privacy_enabled_text" msgid="401238365312924088">"Për ta zhbllokuar, lëviz çelësin e privatësisë në pajisjen tënde në pozicionin e ndezjes së mikrofonit për të lejuar qasjen te mikrofoni."</string>
    <string name="camera" msgid="1226671478936288283">"Kamera"</string>
    <string name="camera_toggle_title" msgid="5566469574224956142">"Qasja te kamera"</string>
    <string name="open_camera_permissions" msgid="301360297337141591">"Qasja e aplikacionit te kamera"</string>
    <string name="camera_physical_privacy_enabled_title" msgid="1944155695921165511">"Qasja te kamera u bllokua"</string>
    <string name="camera_physical_privacy_enabled_text" msgid="6692088634676282779">"Për ta zhbllokuar, lëviz çelësin e privatësisë në pajisjen tënde në pozicionin e ndezjes së kamerës për të lejuar qasjen te kamera."</string>
    <string name="mic_toggle_info_title" msgid="1086545614315873599">"Qasja te mikrofoni: <xliff:g id="SENSOR_STATE">%s</xliff:g>"</string>
    <string name="mic_toggle_info_content" msgid="3187791167208947239">"Kur të aktivizohet, të gjitha aplikacionet dhe shërbimet që lejohet të përdorin mikrofonin do të mund të kenë qasje tek ai.\n\nKur të çaktivizohet, asnjë aplikacion ose shërbim nuk do të mund të ketë qasje te mikrofoni. Por mund të jesh në gjendje të flasësh ende me \"Asistentin e Google\" duke shtypur butonin e \"Asistentit\" në telekomandë.\n\nPajisjet audio që përdorin produkte të personalizuara për të komunikuar me televizorin mund të mos ndikohen nga ky cilësim."</string>
    <string name="mic_remote_toggle_on_info_title" msgid="8503441878870972046">"Mikrofoni u aktivizua në telekomandë"</string>
    <string name="mic_remote_toggle_on_info_content" msgid="2715872916376493679">"\"Asistenti i Google\" mund të ketë qasje te mikrofoni në telekomandë. Do të mund të flasësh me \"Asistentin\" duke shtypur butonin e \"Asistentit të Google\" në telekomandë."</string>
    <string name="mic_remote_toggle_off_info_title" msgid="4902909833546393713">"Mikrofoni u çaktivizua në telekomandë"</string>
    <string name="mic_remote_toggle_off_info_content" msgid="8062526350553191004">"Nuk do të mund të flasësh me \"Asistentin e Google\" duke përdorur telekomandën. Që të mund të përdorësh butonin e \"Asistentit të Google\", aktivizo qasjen te mikrofoni."</string>
    <string name="camera_toggle_info_title" msgid="3871317082313736088">"Qasja te kamera: <xliff:g id="SENSOR_STATE">%s</xliff:g>"</string>
    <string name="camera_toggle_info_content" msgid="2999965953853204003">"Kur kjo është e aktivizuar, të gjitha aplikacionet dhe shërbimet që kanë lejen mund të kenë qasje te çdo kamerë në këtë pajisje.\n\nPajisjet periferike të kamerës me një protokoll të personalizuar nuk do të preken nga ky cilësim."</string>
    <string name="sensor_toggle_info_on" msgid="4568111889147132257">"Aktiv"</string>
    <string name="sensor_toggle_info_off" msgid="7546772458177469821">"Joaktiv"</string>
    <string name="system_location" msgid="4057295363709016511">"Vendndodhja"</string>
    <string name="system_desc_location" msgid="1680134126100535031">"Lejoji aplikacionet që kanë kërkuar lejen tënde të përdorin informacionin e vendndodhjes"</string>
    <string name="system_network_location_confirm" msgid="7128162421781085332">"Miratimi i vendndodhjes"</string>
    <string name="location_mode_title" msgid="728244518174115443">"Modaliteti"</string>
    <string name="location_category_recent_location_requests" msgid="4541924383164183490">"Kërkesat e fundit të vendndodhjes"</string>
    <string name="location_no_recent_apps" msgid="7033474075806435793">"Asnjë aplikacion nuk ka kërkuar vendndodhjen së fundi"</string>
    <string name="location_high_battery_use" msgid="5325556609027887602">"Përdorimi i lartë i baterisë"</string>
    <string name="location_low_battery_use" msgid="728585923412018253">"Përdorim i ulët baterie"</string>
    <string name="location_mode_wifi_description" msgid="84697248707903061">"Përdor Wi‑Fi për të përllogaritur vendndodhjen"</string>
    <string name="location_status" msgid="3037321737386011224">"Statusi i vendndodhjes"</string>
    <string name="location_services" msgid="551503779736382878">"Shërbimet e vendndodhjes"</string>
    <string name="on" msgid="4899322147062342542">"Aktive"</string>
    <string name="off" msgid="3127416478888499352">"Joaktive"</string>
    <string name="google_location_services_title" msgid="6304196603522909239">"Shërbimet e vendndodhjes të Google"</string>
    <string name="third_party_location_services_title" msgid="2826218400381676508">"Shërbimet e vendndodhjes së palës së tretë"</string>
    <string name="location_reporting" msgid="3552501333650895634">"Raportimi i vendndodhjes"</string>
    <string name="location_history" msgid="4055660203090513120">"Historiku i vendndodhjeve"</string>
    <string name="location_reporting_desc" msgid="1580018652781674608">"Google e përdor këtë funksion në produkte si \"Google Tani\" dhe Google Maps. Aktivizimi i \"Raportimit të vendndodhjes\" lejon që çdo produkt i Google që përdor këtë funksion të ruajë dhe të përdorë të dhënat më të fundit të vendndodhjes të pajisjes tënde në lidhje me llogarinë tënde të Google."</string>
    <string name="location_history_desc" msgid="926674012916014270">"Kur \"Historiku i vendndodhjeve\" është i aktivizuar për këtë llogari, Google mund të ruajë të dhënat e vendndodhjes së pajisjes sate për përdorim nga aplikacionet e tua.\n\nPër shembull, Google Maps mund të të japë udhëzime dhe \"Google Tani\" mund të të informojë për trafikun për udhëtimin ditor.\n\nMund ta çaktivizosh \"Historikun e vendndodhjeve\" në çdo kohë, por ky veprim nuk e fshin atë. Për të parë dhe menaxhuar \"Historikun e vendndodhjeve\", vizito maps.google.com/locationhistory."</string>
    <string name="delete_location_history_title" msgid="707559064715633152">"Fshi historikun e vendndodhjeve"</string>
    <string name="delete_location_history_desc" msgid="4035229731487113147">"Kjo do të fshijë të gjithë \"Historikun e vendndodhjeve\" të ruajtur nga kjo pajisje për këtë llogari të Google. Këtë fshirje nuk mund ta zhbësh. Disa aplikacione, duke përfshirë \"Google Tani\", nuk do të funksionojnë më."</string>
    <string name="accessibility_screen_readers_category_title" msgid="7742526514873922018">"Lexuesit e ekranit"</string>
    <string name="accessibility_display_category_title" msgid="593444602101558017">"Ekrani"</string>
    <string name="accessibility_interaction_controls_category_title" msgid="5290687835178852745">"Kontrollet e ndërveprimeve"</string>
    <string name="accessibility_audio_and_onscreen_text_category_title" msgid="113841605896486212">"Audioja dhe teksti në ekran"</string>
    <string name="accessibility_experimental_category_title" msgid="3401773834179170206">"Eksperimentale"</string>
    <string name="accessibility_services_category_title" msgid="8813843874978910442">"Shërbimet"</string>
    <string name="accessibility_service_settings" msgid="3251334786870932423">"Cilësimet e shërbimit"</string>
    <string name="accessibility_screen_reader_flattened_component_name" msgid="6834614827111101213">"com.google.android.marvin.talkback/com.google.android.marvin.talkback.TalkBackService"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="9200419191468995574">"Tekst me kontrast të lartë"</string>
    <string name="accessibility_toggle_bold_text_preference_title" msgid="3328992531170432669">"Tekst i trashësuar"</string>
    <string name="accessibility_color_correction" msgid="6765093204922184119">"Korrigjimi i ngjyrës"</string>
    <string name="color_correction_usage" msgid="4160611639548748657">"Përdor korrigjimin e ngjyrave"</string>
    <string name="color_correction_color_mode" msgid="5081377780734779169">"Modaliteti me ngjyra"</string>
    <string name="color_correction_mode_deuteranomaly" msgid="1513793544554228224">"Deuteranomali"</string>
    <string name="color_correction_mode_deuteranomaly_summary" msgid="5991561481464520986">"E kuqe - e gjelbër"</string>
    <string name="color_correction_mode_protanomaly" msgid="8105793166015115037">"Protanomali"</string>
    <string name="color_correction_mode_protanomaly_summary" msgid="3247619910784115563">"E kuqe - e gjelbër"</string>
    <string name="color_correction_mode_tritanomaly" msgid="757769418392736089">"Tritanomali"</string>
    <string name="color_correction_mode_tritanomaly_summary" msgid="137712354510881252">"E kaltër - e verdhë"</string>
    <string name="color_correction_mode_grayscale" msgid="2592973844160514484">"Nuancat e grisë"</string>
    <string name="palette_color_red" msgid="507196433434979086">"E kuqe"</string>
    <string name="palette_color_orange" msgid="6209196069366109835">"Portokalli"</string>
    <string name="palette_color_yellow" msgid="298466132578870590">"E verdhë"</string>
    <string name="palette_color_green" msgid="4904783063036825668">"E gjelbër"</string>
    <string name="palette_color_cyan" msgid="3212217287628948203">"Gurkali"</string>
    <string name="palette_color_blue" msgid="8836682634988540630">"Blu"</string>
    <string name="palette_color_purple" msgid="2123828754639683555">"Vjollcë"</string>
    <string name="palette_color_gray" msgid="4014534773994261194">"Gri"</string>
    <string name="accessibility_shortcut" msgid="5856158637840030531">"Shkurtorja e qasshmërisë"</string>
    <string name="accessibility_shortcut_enable" msgid="6603542432267329986">"Aktivizo shkurtoren e qasshmërisë"</string>
    <string name="accessibility_shortcut_service" msgid="2053250146891420311">"Shërbimi i shkurtores"</string>
    <string name="accessibility_shortcut_description" msgid="2050424178481510046">"Kur shkurtorja është e aktivizuar, shtypja njëkohësisht e butonit të pasmë dhe të poshtëm për 3 sekonda do të nisë një funksion qasshmërie."</string>
    <string name="accessibility_timeout" msgid="5806441204926407081">"Koha për të kryer veprime"</string>
    <string name="accessibility_timeout_detailed" msgid="3671649651457927559">"Veprimi (koha e pritjes së \"Qasshmërisë\")"</string>
    <string name="accessibility_timeout_info_title" msgid="6436020666160017491">"Koha"</string>
    <string name="accessibility_timeout_info_description" msgid="443750173070723088">"Kjo preferencë e kohës nuk mbështetet nga të gjitha aplikacionet."</string>
    <string name="accessibility_captions" msgid="3411554568812306549">"Titrat"</string>
    <string name="accessibility_captions_description" msgid="3827820027578548160">"Cilësimet për mbivendosjen e tekstit të titrave në video"</string>
    <string name="captions_display" msgid="2598662495450633375">"Ekrani"</string>
    <string name="captions_display_on" msgid="480438033345455728">"Aktive"</string>
    <string name="captions_display_off" msgid="87881163874948539">"Joaktive"</string>
    <string name="display_options" msgid="2645282080948371603">"Opsionet e paraqitjes"</string>
    <string name="captions_configure" msgid="711991018642931958">"Konfiguro"</string>
    <string name="captions_language" msgid="5905918439449912646">"Gjuha"</string>
    <string name="captions_language_default" msgid="3894192926725192528">"E parazgjedhur"</string>
    <string name="captions_textsize" msgid="7161136610669343510">"Madhësia e tekstit"</string>
    <string name="captions_captionstyle" msgid="6650139717545516071">"Stili i titrave"</string>
    <string name="captions_customoptions" msgid="7691004663572161126">"Opsionet e personalizuara"</string>
    <string name="captions_fontfamily" msgid="1026632786438880997">"Familja e shkrimit"</string>
    <string name="captions_textcolor" msgid="1566679779609140317">"Ngjyra e tekstit"</string>
    <string name="captions_edgetype" msgid="4875636291904824401">"Lloji i skajeve"</string>
    <string name="captions_edgecolor" msgid="2779925179084237336">"Ngjyra e skajit"</string>
    <string name="captions_backgroundshow" msgid="1080183686470477645">"Shfaq sfondin"</string>
    <string name="captions_backgroundcolor" msgid="2056944109914399253">"Ngjyra e sfondit"</string>
    <string name="captions_backgroundopacity" msgid="1850126438162000027">"Niveli i transparencës së sfondit"</string>
    <string name="captioning_preview_text" msgid="3034147586392743237">"Titrat do të duken kështu"</string>
    <string name="captions_textopacity" msgid="6055602491649526307">"Transparenca e tekstit"</string>
    <string name="captions_windowshow" msgid="6002072054703167886">"Shfaq dritaren"</string>
    <string name="captions_windowcolor" msgid="7460430328878876648">"Ngjyra e dritares"</string>
    <string name="captions_windowopacity" msgid="8645082670322789314">"Transparenca e dritares"</string>
    <string name="captions_style_0" msgid="169414884289770256">"E bardhë mbi të zezë"</string>
    <string name="captions_style_1" msgid="8236052739817535538">"E zezë mbi të bardhë"</string>
    <string name="captions_style_2" msgid="456353889540431910">"E verdhë mbi të zezë"</string>
    <string name="captions_style_3" msgid="3860050153620761166">"E verdhë mbi blu"</string>
    <string name="captions_style_custom" msgid="9062905566459387931">"E personalizuar"</string>
    <string name="color_white" msgid="4188877187457167678">"E bardhë"</string>
    <string name="color_black" msgid="2631818627391955149">"E zezë"</string>
    <string name="color_red" msgid="1899020130465926495">"E kuqe"</string>
    <string name="color_green" msgid="7546929005626106667">"E gjelbër"</string>
    <string name="color_blue" msgid="7681690245150985958">"Blu"</string>
    <string name="color_cyan" msgid="3172130225116530998">"Gurkali"</string>
    <string name="color_yellow" msgid="3519470952904560404">"E verdhë"</string>
    <string name="color_magenta" msgid="2377854703399624607">"E purpurt"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="933923296129403548">"Përshkrimi i audios"</string>
    <string name="accessibility_audio_description_summary" msgid="2027813223650517036">"Dëgjo një përshkrim të asaj që ndodh në ekran te filmat dhe shfaqjet e mbështetura"</string>
    <string name="system_accessibility_status" msgid="8504842254080682515">"Aktivizo"</string>
    <string name="system_accessibility_config" msgid="4820879735377962851">"Konfigurimi"</string>
    <string name="system_accessibility_service_on_confirm_title" msgid="4547924421106540376">"Të përdoret <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="system_accessibility_service_on_confirm_desc" msgid="5426217096813804569">"<xliff:g id="SERVICE">%1$s</xliff:g> do të jetë në gjendje të të lexojë ekranin, të shfaqë përmbajtjen mbi aplikacione të tjera, të gjurmojë ndërveprimet e tua me aplikacionet ose sensorët e harduerit dhe të ndërveprojë me aplikacionet në emrin tënd."</string>
    <string name="system_accessibility_service_off_confirm_title" msgid="1110904358228641834">"Të ndalohet <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="system_accessibility_service_off_confirm_desc" msgid="3486513644923267157">"Zgjedhja e \"Në rregull\" do të ndalojë shërbimin <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="system_accessibility_tts_output" msgid="3186078508203212288">"Tekst në ligjërim"</string>
    <string name="system_accessibility_tts_engine_config" msgid="4757760652785865532">"Konfigurimi i motorit"</string>
    <string name="system_speak_passwords" msgid="8556036524146404052">"Thuaji fjalëkalimet me zë"</string>
    <string name="system_preferred_engine" msgid="3545505072652708443">"Motori i preferuar"</string>
    <string name="system_speech_rate" msgid="6553204071403872669">"Shpejtësia e të folurit"</string>
    <string name="system_play_sample" msgid="3934369914309865584">"Luaj një shembull"</string>
    <string name="system_install_voice_data" msgid="8016395777968958673">"Instalo të dhënat e zërit"</string>
    <string name="system_general" msgid="687760148454147771">"Të përgjithshme"</string>
    <string name="system_debugging" msgid="1576324426385458481">"Korrigjimi i gabimeve"</string>
    <string name="system_input" msgid="4457152980514604873">"Hyrja"</string>
    <string name="system_drawing" msgid="5802739024643871942">"Vizatimi"</string>
    <string name="system_monitoring" msgid="7997260748312620855">"Monitorimi"</string>
    <string name="system_apps" msgid="8481888654606868074">"Aplikacionet"</string>
    <string name="system_stay_awake" msgid="5935117574414511413">"Qëndro zgjuar"</string>
    <string name="keep_screen_on_summary" msgid="4680661166009970792">"Ekrani nuk do të kalojë asnjëherë në gjumë"</string>
    <string name="system_hdcp_checking" msgid="3757586362130048838">"Kontrolli i HDCP-së"</string>
    <string name="system_hdmi_optimization" msgid="4122753440620724144">"Optimizimi i HDMI-së"</string>
    <string name="system_reboot_confirm" msgid="7035370306447878560">"Të riniset tani?"</string>
    <string name="system_desc_reboot_confirm" msgid="1567738857421128179">"Për të përditësuar këtë cilësim, pajisja jote duhet të riniset"</string>
    <string name="system_never_check" msgid="2860070727606369055">"Mos kontrollo asnjëherë"</string>
    <string name="system_check_for_drm_content_only" msgid="6667617772587997533">"Kontrollo vetëm për përmbajtje DRM"</string>
    <string name="system_always_check" msgid="384870282800221580">"Kontrollo gjithmonë"</string>
    <string name="system_bt_hci_log" msgid="1891838112637932603">"Regjistrimi i Bluetooth HCI"</string>
    <string name="system_email_address" msgid="3725494874473757217">"Adresa e email-it"</string>
    <string name="system_usb_debugging" msgid="2158285492172755923">"Korrigjimi përmes USB-së"</string>
    <string name="system_allow_mock_locations" msgid="2483106887711851466">"Lejo vendndodhje të simuluara"</string>
    <string name="system_select_debug_app" msgid="6200987902307533721">"Zgjidh aplikacionin e korrigjimit"</string>
    <string name="system_wait_for_debugger" msgid="5715878008542589060">"Prit për korrigjuesin"</string>
    <string name="system_verify_apps_over_usb" msgid="7289212844195483932">"Verifiko apl. përmes USB-së"</string>
    <string name="system_desc_verify_apps_over_usb" msgid="7737988681480237094">"Kontrollo aplikacionet e instaluara nëpërmjet ADB/ADT për sjellje të dëmshme"</string>
    <string name="system_wifi_verbose_logging" msgid="3097788974146704831">"Regjistrimi i zgjeruar i Wi-Fi"</string>
    <string name="system_desc_wifi_verbose_logging" msgid="3537578245428327314">"Aktivizo regjistrimin e zgjeruar të Wi-Fi"</string>
    <string name="system_show_touches" msgid="8244331695139748286">"Shfaq prekjet"</string>
    <string name="system_pointer_location" msgid="8724050865245555084">"Vendndodhja e treguesit"</string>
    <string name="system_show_layout_bounds" msgid="8803080672553699649">"Shfaq konturet e strukturës"</string>
    <string name="system_show_gpu_view_updates" msgid="1625918928089365222">"Shfaq përditësimet e pamjes së GPU-së"</string>
    <string name="system_show_hardware_layer" msgid="5833664339844452290">"Shfaq shtresën e harduerit"</string>
    <string name="system_show_gpu_overdraw" msgid="5073007513540516704">"Shfaq mbivendosjen e GPU-së"</string>
    <string name="system_show_surface_updates" msgid="7680759813613585278">"Shfaq përditësimet e sipërfaqes"</string>
    <string name="system_window_animation_scale" msgid="685477540250939659">"Shkalla e animacionit të dritares"</string>
    <string name="system_transition_animation_scale" msgid="7266380208347453619">"Shkalla e animacionit kalimtar"</string>
    <string name="system_animator_duration_scale" msgid="3829445237130423625">"Shkalla e kohëzgjatjes së animatorit"</string>
    <string name="system_strict_mode_enabled" msgid="7392183793064579588">"Aktivizo modalitetin e rreptë"</string>
    <string name="system_profile_gpu_rendering" msgid="1113416260742329348">"Interpretimi i profilit të GPU-së"</string>
    <string name="system_enable_traces" msgid="108745519968154528">"Aktivizo gjurmët"</string>
    <string name="system_dont_keep_activities" msgid="4641165963339846161">"Mos i ruaj aktivitetet"</string>
    <string name="system_background_process_limit" msgid="1985373407150771045">"Kufiri i proceseve në sfond"</string>
    <string name="system_show_all_anrs" msgid="5353216640638263217">"Shfaq të gjitha raportet ANR"</string>
    <string name="system_desc_stay_awake" msgid="8485868071929937500">"Çaktivizo gjumin"</string>
    <string name="system_desc_hdcp_checking" msgid="1664068008848077241">"Përdor vetëm për përmbajtje DRM"</string>
    <string name="system_desc_hdmi_optimization" msgid="5695603795556335912">"Optimizo ekranin për rezolucionin maksimal ose shpejtësinë maksimale të kuadrove. Kjo ndikon vetëm tek ekranet Ultra HD. Ndryshimi i këtij cilësimi do ta rinisë pajisjen tënde."</string>
    <string name="system_desc_bt_hci_log" msgid="2592649923221658103">"Aktivizo regjistrin testues të paketave HCI të Bluetooth-it"</string>
    <string name="system_desc_usb_debugging" msgid="5672275208185222785">"Modaliteti i korrigjimit të gabimeve kur USB-ja është e lidhur"</string>
    <string name="system_desc_wait_for_debugger" msgid="7213496668606417691">"Aplikacioni i korrigjimit të gabimeve pret që korrigjuesi të bashkëngjitet para ekzekutimit"</string>
    <string name="system_desc_show_layout_bounds" msgid="5275008598296135852">"Shfaq konturet e klipit, hapësirat, etj."</string>
    <string name="system_desc_show_gpu_view_updates" msgid="9088343415389734854">"Ndriço pamjet brenda dritareve kur dizajnohen me GPU-në"</string>
    <string name="system_desc_show_hardware_layer" msgid="3483713991865249527">"Ndriço në të gjelbër shtresat e harduerit që përditësohen"</string>
    <string name="system_desc_show_gpu_overdraw" msgid="74019834911598588">"Nga më e mira te më e keqja: blu, e gjelbër, e kuqe e çelur, e kuqe"</string>
    <string name="system_desc_show_surface_updates" msgid="4018685547515133353">"Ndriço të gjitha sipërfaqet e dritares kur ato të përditësohen"</string>
    <string name="system_desc_strict_mode_enabled" msgid="1974896408481676324">"Ndriço ekranin kur aplikacionet kryejnë veprime të gjata në pjesën kryesore të procesit"</string>
    <string name="system_desc_profile_gpu_rendering" msgid="1594070211030991">"Mat kohën e interpretimit në \"adb shell dumpsys gfxinfo\""</string>
    <string name="security_unknown_sources_title" msgid="2012801664240314305">"Burime të panjohura"</string>
    <string name="security_unknown_sources_desc" msgid="7196715598352173267">"Lejo instalimin e aplikacioneve nga burime të ndryshme nga \"Dyqani i Play\""</string>
    <string name="security_unknown_sources_confirm_title" msgid="4600896691987804985">"Lejo burimet e panjohura"</string>
    <string name="security_unknown_sources_confirm_desc" msgid="7883820068140189584">"Pajisja dhe të dhënat e tua personale janë më të cenueshme nga sulmet nga aplikacione nga burime të panjohura. Ti pranon se je përgjegjës për çdo dëm ndaj pajisjes ose çdo humbje të të dhënave që mund të rezultojë nga përdorimi i këtyre aplikacioneve."</string>
    <string name="system_hdcp_checking_never" msgid="3251512398865365135">"Asnjëherë"</string>
    <string name="system_hdcp_checking_drm" msgid="2159124883496899278">"Për përmbajtjen DRM"</string>
    <string name="system_hdcp_checking_always" msgid="5868177105455148262">"Gjithmonë"</string>
    <string name="system_hdmi_optimization_best_resolution" msgid="4916028940107998097">"Rezolucioni më i mirë"</string>
    <string name="system_hdmi_optimization_best_framerate" msgid="3778579148517609370">"Shpejtësia më e mirë e kuadrove"</string>
    <string name="system_hw_overdraw_off" msgid="6637679040053936280">"Joaktive"</string>
    <string name="system_hw_overdraw_areas" msgid="6442009722913530348">"Shfaq zonat e mbivendosjes"</string>
    <string name="system_hw_overdraw_counter" msgid="9132113146364838852">"Shfaq numëruesin e mbivendosjes"</string>
    <string name="no_application" msgid="1904437693440706534">"Asgjë"</string>
    <string name="enable_opengl_traces_none" msgid="4718084947494592040">"Asnjë"</string>
  <string-array name="animation_scale_entries">
    <item msgid="5408992662476056082">"Animacioni është joaktiv"</item>
    <item msgid="6818290063799857019">"Shkalla e animacionit 0,5x"</item>
    <item msgid="8257959452691080724">"Shkalla e aminacionit 1x"</item>
    <item msgid="4781052272686018414">"Shkalla e animacionit 1,5x"</item>
    <item msgid="2272016945160227610">"Shkalla e animacionit 2x"</item>
    <item msgid="5015441793276576312">"Shkalla e animacionit 5x"</item>
    <item msgid="1290233583371556415">"Shkalla e animacionit 10x"</item>
  </string-array>
    <string name="track_frame_time_off" msgid="8845064783618702239">"Joaktive"</string>
    <string name="track_frame_time_bars" msgid="5841531515222229632">"Në ekran si shirita"</string>
    <string name="app_process_limit_standard" msgid="6069948528843313888">"Kufiri standard"</string>
    <string name="app_process_limit_zero" msgid="4094665021909774994">"Nuk ka procese në sfond"</string>
    <string name="app_process_limit_one" msgid="4509089015775863726">"Maksimumi 1 proces"</string>
    <string name="app_process_limit_two" msgid="368216781690488529">"Maksimumi 2 procese"</string>
    <string name="app_process_limit_three" msgid="2191860654645796987">"Maksimumi 3 procese"</string>
    <string name="app_process_limit_four" msgid="9186705437061005461">"Maksimumi 4 procese"</string>
    <string name="tts_rate_very_slow" msgid="1927454053669655117">"Shumë e ngadaltë"</string>
    <string name="tts_rate_slow" msgid="7668484707347561166">"E ngadaltë"</string>
    <string name="tts_rate_normal" msgid="3631458247079252628">"Normale"</string>
    <string name="tts_rate_fast" msgid="5723868816257531421">"E shpejtë"</string>
    <string name="tts_rate_very_fast" msgid="7756663146626103952">"Shumë e shpejtë"</string>
    <string name="title_settings" msgid="780933693363320088">"Cilësimet e <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="title_current_keyboard" msgid="891238509164879851">"Tastiera aktuale"</string>
    <string name="title_configure" msgid="846802387014612210">"Konfiguro"</string>
    <string name="desc_configure_keyboard" msgid="3474279140150468141">"Opsionet e tastierës"</string>
    <string name="title_current_autofill_service" msgid="9029001041887283153">"Shërbimi aktual i plotësimit automatik"</string>
    <string name="title_select_autofill_service" msgid="696559582725756848">"Zgjidh \"Shërbimin e plotësimit automatik\""</string>
    <string name="autofill_none" msgid="1615056985649424207">"Asnjë"</string>
    <string name="autofill_confirmation_message" msgid="3840267789160192558">"&lt;b&gt;Sigurohu që ke besim te ky aplikacion&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Shërbimi i fjalëkalimit&gt;%1$s&lt;/xliff:g&gt; përdor atë që ndodhet në ekranin tënd për të përcaktuar se çfarë mund të plotësohet automatikisht."</string>
    <string name="computing_size" msgid="8623916230485437579">"Po llogarit…"</string>
    <string name="title_select_wifi_network" msgid="935820896444071617">"Zgjidh rrjetin tënd Wi-Fi"</string>
    <string name="accessories_wifi_display_rename_device" msgid="8803397194143132061">"Riemërto"</string>
    <string name="accessories_wifi_display_enable" msgid="2385467074170316302">"Ekrani i Wi-Fi"</string>
    <string name="accessories_wifi_display_pin_required" msgid="5434960694140426664">"Kërkohet kodi PIN"</string>
    <string name="whichApplication" msgid="4510042089342879264">"Përfundo veprimin duke përdorur"</string>
    <string name="alwaysUseQuestion" msgid="2643084054296937138">"Të përdoret gjithmonë ky opsion për këtë veprim?"</string>
    <string name="alwaysUseOption" msgid="8799609235198714441">"Përdor gjithmonë"</string>
    <string name="justOnceOption" msgid="6714005843102804865">"Vetëm një herë"</string>
    <string name="noApplications" msgid="7511175717026318399">"Asnjë aplikacion nuk mund ta kryejë këtë veprim."</string>
    <string name="noAppsGoBack" msgid="2538480554615467065">"Prapa"</string>
    <string name="inputs_inputs" msgid="8639408473661259307">"Hyrjet"</string>
    <string name="inputs_header_cec" msgid="4139015942980115323">"Kontrolli elektronik i konsumatorit (CEC)"</string>
    <string name="inputs_cec_settings" msgid="5948357769198260080">"Cilësimet e kontrollit të pajisjes"</string>
    <string name="inputs_blu_ray" msgid="6561004081102615775">"Blu-ray"</string>
    <string name="inputs_cable" msgid="8274665772422377063">"Kabllo"</string>
    <string name="inputs_dvd" msgid="1452146927899250552">"DVD"</string>
    <string name="inputs_game" msgid="4762255172943107070">"Konsola e lojërave"</string>
    <string name="inputs_aux" msgid="5331442342029867329">"Aux"</string>
    <string name="inputs_custom_name" msgid="2649826613531559538">"Emri i personalizuar"</string>
    <string name="inputs_custom_name_description_fmt" msgid="2879134265596928298">"Fut një emër për hyrjen <xliff:g id="INPUT">%1$s</xliff:g>."</string>
    <string name="inputs_hide" msgid="9223355763198742416">"E fshehur"</string>
    <string name="inputs_show" msgid="2937435050499142756">"Shfaq këtë hyrje"</string>
    <string name="input_header_names" msgid="5903234218909970550">"Emri"</string>
    <string name="inputs_hdmi_control" msgid="650355636965841054">"Kontrolli i HDMI-së"</string>
    <string name="inputs_hdmi_control_desc" msgid="306769914209526682">"Lejo që televizori të kontrollojë pajisjet HDMI"</string>
    <string name="inputs_device_auto_off" msgid="2659766884754402352">"Fikja automatike e pajisjes"</string>
    <string name="inputs_device_auto_off_desc" msgid="1164897242719608201">"Fik pajisjet HDMI me televizorin"</string>
    <string name="inputs_tv_auto_on" msgid="544848340484583318">"Ndezja automatike e televizorit"</string>
    <string name="inputs_tv_auto_on_desc" msgid="3640723210479925817">"Ndize televizorin me pajisjen HDMI"</string>
    <string name="inputs_header_connected_input" msgid="4323324944548164849">"{count,plural, =1{Hyrje e lidhur}other{Hyrje të lidhura}}"</string>
    <string name="inputs_header_standby_input" msgid="600117963181008144">"{count,plural, =1{Hyrje në gatishmëri}other{Hyrje në gatishmëri}}"</string>
    <string name="inputs_header_disconnected_input" msgid="3852361100151289264">"{count,plural, =1{Nuk ka hyrje të lidhur}other{Nuk ka hyrje të lidhura}}"</string>
    <string name="user_add_profile_item_summary" msgid="3211866291940617804">"Kufizo qasjen tek aplikacionet dhe përmbajtjet e tjera në llogarinë tënde"</string>
    <string name="user_new_profile_name" msgid="6637593067318708353">"Profil i kufizuar"</string>
    <string name="user_restrictions_controlled_by" msgid="8124926446168030445">"Kontrollohet nga <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_not_supported_in_limited" msgid="4046604594925826955">"Ky aplikacion nuk mbështetet në profile të kufizuara"</string>
    <string name="app_sees_restricted_accounts" msgid="174038126799649152">"Ky aplikacion mund të ketë qasje në llogaritë e tua"</string>
    <string name="restriction_location_enable_title" msgid="2552780806199464266">"Vendndodhja"</string>
    <string name="restriction_location_enable_summary" msgid="3719330231217994482">"Lejo aplikacionet të përdorin informacionin e vendndodhjes tënde"</string>
    <string name="restricted_profile_switch_to" msgid="6193201935877168764">"Hyr te profili i kufizuar"</string>
    <string name="restricted_profile_switch_out" msgid="3589381233390753413">"Dil nga profili i kufizuar"</string>
    <string name="restricted_profile_delete_title" msgid="7153982195273379506">"Fshi profilin e kufizuar"</string>
    <string name="restricted_profile_create_title" msgid="700322590579894058">"Krijo një profil të kufizuar"</string>
    <string name="restricted_profile_configure_title" msgid="3327502517511010296">"Cilësimet"</string>
    <string name="restricted_profile_configure_apps_title" msgid="2244201859522056827">"Aplikacionet e lejuara"</string>
    <string name="restricted_profile_allowed" msgid="970921490464867884">"Lejohet"</string>
    <string name="restricted_profile_not_allowed" msgid="8184983064118036268">"Nuk lejohet"</string>
    <string name="restricted_profile_customize_restrictions" msgid="4723577877385636704">"Personalizo kufizimet"</string>
    <string name="restricted_profile_configure_apps_description_loading" msgid="3293508876131962699">"Një moment..."</string>
    <string name="restricted_profile_change_password_title" msgid="6961384850606763601">"Ndrysho kodin PIN"</string>
    <string name="restricted_profile_create_preference_screen" msgid="3263536648469645089">"Të krijohet profil i kufizuar?"</string>
    <string name="restricted_profile_already_created_placeholder" msgid="8619544048199836920">"Është krijuar tashmë"</string>
    <string name="restricted_profile_skip_action" msgid="4674562040162193593">"Kapërce"</string>
    <string name="restricted_profile_create_pin_action" msgid="1883036507880250231">"Krijo kodin PIN"</string>
    <string name="restricted_profile_enter_preference_screen" msgid="676246260867597333">"Të hapet profili i kufizuar?"</string>
    <string name="restricted_profile_enter_not_found_placeholder" msgid="2270969471829375976">"Nuk ka profil të kufizuar"</string>
    <string name="restricted_profile_enter_already_entered_placeholder" msgid="6178278708529027598">"Ke hyrë tashmë"</string>
    <string name="restriction_description" msgid="2053112392083722259">"<xliff:g id="DESCRIPTION">%1$s</xliff:g>\n<xliff:g id="VALUE">%2$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="1261056180558324892">"Ky aplikacion mund të qaset te llogaritë e tua. Kontrollohet nga <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="pin_enter_unlock_channel" msgid="243855138978654080">"Fut kodin PIN për të shikuar këtë kanal"</string>
    <string name="pin_enter_unlock_program" msgid="275489015420025531">"Fut kodin PIN për të shikuar këtë program"</string>
    <string name="pin_enter_pin" msgid="5020029261153234751">"Fut kodin PIN"</string>
    <string name="pin_enter_new_pin" msgid="1930944619313642621">"Cakto një kod të ri PIN"</string>
    <string name="pin_enter_again" msgid="7615050143778858658">"Fut përsëri kodin e ri PIN"</string>
    <string name="pin_enter_old_pin" msgid="5665265735227617942">"Fut kodin e vjetër PIN"</string>
    <string name="pin_enter_wrong_seconds" msgid="3014013615537066237">"Ke futur kodin e gabuar PIN 5 herë.\nProvo përsëri pas <xliff:g id="RELATIVE_TIME_SPAN">%1$d</xliff:g> sekondash."</string>
    <string name="pin_toast_wrong" msgid="4297542365877164402">"Kodi PIN është i gabuar. Provo përsëri."</string>
    <string name="pin_toast_not_match" msgid="2439298696342975155">"Kodi PIN nuk përputhet. Provo përsëri."</string>
    <string name="wifi_setup_input_password" msgid="8510003548463241234">"Fut fjalëkalimin për <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_setup_description" msgid="6843574399437584520">"Zgjidh <xliff:g id="WIFI_SUBMIT_ICON">%1$s</xliff:g> për të vazhduar."</string>
    <string name="label_done_key" msgid="8576286462300373440">"U krye"</string>
    <string name="wifi_setup_connection_success" msgid="3301901673876973474">"U lidh me sukses"</string>
    <string name="wifi_setup_already_connected" msgid="2135251990280273625">"Është lidhur tashmë"</string>
    <string name="wifi_setup_save_success" msgid="6862510218032734919">"U ruajt me sukses"</string>
    <string name="device_apps_app_management_version" msgid="2119174719194899740">"Versioni <xliff:g id="APP_VERSION">%1$s</xliff:g>"</string>
    <string name="device_apps_app_management_open" msgid="4249743535677261897">"Hap"</string>
    <string name="device_apps_app_management_force_stop" msgid="4454221309989640309">"Ndalo me forcë"</string>
    <string name="device_apps_app_management_force_stop_desc" msgid="1980972142863114899">"Nëse e ndalon me forcë një aplikacion, ai mund të paraqesë çrregullime në funksionim."</string>
    <string name="device_apps_app_management_uninstall" msgid="4171103696233332967">"Çinstalo"</string>
    <string name="device_apps_app_management_uninstall_updates" msgid="5647988075828648951">"Çinstalo përditësimet"</string>
    <string name="device_apps_app_management_uninstall_updates_desc" msgid="4508586498292236706">"Të gjitha përditësimet në këtë sistem Android do të çinstalohen."</string>
    <string name="device_apps_app_management_disable" msgid="819003297535493633">"Çaktivizo"</string>
    <string name="device_apps_app_management_disable_desc" msgid="9143166267511427607">"Dëshiron që ta çaktivizosh këtë aplikacion?"</string>
    <string name="device_apps_app_management_enable" msgid="9173340340253029114">"Aktivizo"</string>
    <string name="device_apps_app_management_enable_desc" msgid="8686291003061136476">"Dëshiron që ta aktivizosh këtë aplikacion?"</string>
    <string name="device_apps_app_management_storage_used" msgid="6725789557993296433">"Hapësira ruajtëse e përdorur"</string>
    <string name="device_apps_app_management_storage_used_desc" msgid="8928632612101487179">"<xliff:g id="SIZE">%1$s</xliff:g> përdorur në <xliff:g id="VOLUME">%2$s</xliff:g>"</string>
    <string name="device_apps_app_management_clear_data" msgid="7305471678286735600">"Pastro të dhënat"</string>
    <string name="device_apps_app_management_clear_data_desc" msgid="170972356946852847">"Të gjitha të dhënat e këtij aplikacioni do të fshihen përgjithmonë.\nKjo përfshin të gjithë skedarët, cilësimet, llogaritë, bazat e të dhënave, etj."</string>
    <string name="device_apps_app_management_clear_default" msgid="4566187319647111484">"Fshi parazgjedhjet"</string>
    <string name="device_apps_app_management_clear_default_set" msgid="1649974109123107390">"Cakto që ta hapësh këtë aplikacion për disa veprime"</string>
    <string name="device_apps_app_management_clear_default_none" msgid="5935252537185381597">"Nuk janë caktuar parazgjedhje"</string>
    <string name="device_apps_app_management_clear_cache" msgid="2678301483598915479">"Pastro memorien specifike"</string>
    <string name="device_apps_app_management_notifications" msgid="1687529279264810317">"Njoftime"</string>
    <string name="device_apps_app_management_licenses" msgid="4809737266551899869">"Kodi burimor nga një palë e tretë"</string>
    <string name="device_apps_app_management_permissions" msgid="4951820230491375037">"Lejet"</string>
    <string name="device_apps_app_management_not_available" msgid="4198634078194500518">"Aplikacioni nuk disponohet"</string>
    <string name="unused_apps" msgid="5539166745483454543">"Aplikacionet e papërdorura"</string>
    <string name="settings_ok" msgid="5950888975075541964">"Në rregull"</string>
    <string name="settings_confirm" msgid="4489126458677153411">"Konfirmo"</string>
    <string name="settings_cancel" msgid="576094334743686152">"Anulo"</string>
    <string name="settings_on" msgid="7734010120323404333">"Aktive"</string>
    <string name="settings_off" msgid="4060451657850476369">"Joaktive"</string>
    <string name="device_daydreams_none" msgid="3405655350757277348">"Çaktivizo ekranin"</string>
    <string name="device_daydreams_select" msgid="7203264446482623438">"Mbrojtësi i ekranit"</string>
    <string name="device_daydreams_test" msgid="7828275397550076567">"Fillo tani"</string>
    <string name="device_daydreams_sleep" msgid="6847770718407377357">"Kur të fillojë"</string>
    <string name="device_daydreams_sleep_description" msgid="6237610484915504587">"Mbrojtësi i ekranit fillon pas kësaj periudhe pa aktivitet. Nëse nuk është zgjedhur asnjë mbrojtës ekrani, ekrani do të çaktivizohet."</string>
    <string name="device_daydreams_sleep_summary" msgid="3081688734381995693">"Pas <xliff:g id="SLEEP_DESCRIPTION">%1$s</xliff:g> pa aktivitet"</string>
    <string name="device_energy_saver_screen_off" msgid="6908468996426629480">"Fik ekranin"</string>
    <!-- no translation found for device_energy_saver_timeout_description (3206609135199137514) -->
    <skip />
    <string name="device_energy_saver_confirmation_title" msgid="7614859812773584773">"Konfirmo cilësimin e fuqisë dhe energjisë"</string>
    <string name="device_energy_saver_confirmation_message" msgid="7789453187001013951">"Lënia e televizorit ndezur për një kohë të gjatë mund të rrisë përdorimin e energjisë"</string>
    <string name="device_energy_saver_disable_allow_turning_screen_off_title" msgid="1468097048101593731">"Çaktivizo cilësimin e kursyesit të energjisë"</string>
    <string name="device_energy_saver_disable_allow_turning_screen_off_text" msgid="6334963903866002164">"Konfirmo për të parandaluar fikjen e ekranit gjatë shikimit, pasi kjo ka mundësi të konsumojë më shumë energji."</string>
    <string name="device_energy_saver_sleep_timeout" msgid="1841900768718452039">"Gjatë mungesës së aktivitetit"</string>
    <string name="device_energy_saver_attentive_timeout" msgid="3649486668821348087">"Gjatë shikimit"</string>
    <string name="device_energy_saver_category_title" msgid="170076161677525986">"Çaktivizoje automatikisht"</string>
    <string name="device_energy_saver_sleep_timeout_dialog_title" msgid="6588352532253294558">"Çaktivizoje automatikisht kur është joaktive"</string>
    <string name="device_energy_saver_attentive_timeout_dialog_title" msgid="3273988875711109352">"Çaktivizoje automatikisht kur je duke shikuar"</string>
    <string name="device_energy_saver_validation_sleep" msgid="7490897287741107840">"Kohëmatësi \"Gjatë mungesës së aktivitetit\" duhet të jetë më i shkurtër se kohëmatësi \"Gjatë shikimit\""</string>
    <string name="device_energy_saver_validation_attentive" msgid="1461105528087097435">"Kohëmatësi \"Gjatë shikimit\" duhet të jetë më i gjatë se kohëmatësi \"Gjatë mungesës së aktivitetit\""</string>
    <string name="limit_network_in_standby_toggle_title" msgid="6587185599397355336">"Kufizo lidhjen me rrjetin në gatishmëri"</string>
    <string name="limit_network_in_standby_toggle_summary" msgid="9127792748675581174">"Përdor më pak energji në modalitetin e gatishmërisë"</string>
    <string name="limit_network_in_standby_toggle_info" msgid="566947772381093991">"Televizori do të shkëputet nga rrjeti kur të jetë në modalitetin e gatishmërisë, me përjashtim të marrjes së përditësimeve automatike. Kjo mund të ulë përdorimin e energjisë së televizorit, megjithëse nënkupton gjithashtu që mund të mos jesh në gjendje të përdorësh funksione si Google Cast dhe \"Asistenti i Google\" ndërkohë që është në gatishmëri."</string>
    <string name="limit_network_in_standby_confirm_title" msgid="789232987058850322">"Lejo lidhjen e rrjetit në gatishmëri"</string>
    <string name="limit_network_in_standby_confirm_message" msgid="7176699480768019689">"Lejimi i lidhjes së rrjetit në gatishmëri do të rrisë përdorimin e energjisë në gatishmëri."</string>
    <string name="backup_configure_account_default_summary" msgid="2170733614341544296">"Asnjë llogari nuk po ruan aktualisht të dhënat e rezervuara"</string>
    <string name="backup_erase_dialog_title" msgid="6008454053276987100"></string>
    <string name="backup_erase_dialog_message" msgid="222169533402624861">"Të ndalohet rezervimi i fjalëkalimeve të Wi-Fi, faqeshënuesve, cilësimeve të tjera dhe të dhënave të aplikacioneve dhe të spastrohen të gjitha kopjet në serverët e Google?"</string>
    <string name="privacy_backup_data" msgid="3604057980102997914">"Rezervo të dhënat e mia"</string>
    <string name="privacy_backup_account" msgid="4527813051841860610">"Llogaria e rezervimit"</string>
    <string name="privacy_automatic_restore" msgid="7117805818589418118">"Restaurimi automatik"</string>
    <string name="factory_reset_device" msgid="6509900821515094361">"Rivendos pajisjen"</string>
    <string name="factory_reset_description" msgid="6697396335158766785">"Kjo do të ta rikthejë pajisjen në cilësimet bazë dhe do të të fshijë të gjitha të dhënat, llogaritë, skedarët dhe aplikacionet e shkarkuara."</string>
    <string name="factory_reset_info_description" msgid="5098454670833183487">"Kjo do të ta rikthejë pajisjen në cilësimet bazë dhe do të të fshijë të gjitha të dhënat, llogaritë, skedarët dhe aplikacionet e shkarkuara."</string>
    <string name="factory_reset_content_description" msgid="1677022688420116803">"\"Rivendosje në gjendje fabrike\", kjo do të ta rikthejë pajisjen në cilësimet bazë dhe do të të fshijë të gjitha të dhënat, llogaritë, skedarët dhe aplikacionet e shkarkuara."</string>
    <string name="confirm_factory_reset_description" msgid="1337483463207721713">"Do t\'i spastrosh të gjitha informacionet personale dhe aplikacionet e shkarkuara në këtë pajisje? Këtë veprim nuk mund ta kthesh mbrapsht!"</string>
    <string name="confirm_factory_reset_device" msgid="4308646529880718465">"Spastroji të gjitha"</string>
    <string name="select_device_name_title" msgid="3045019448327493634">"Zgjidh një emër për pajisjen tënde <xliff:g id="DEVICEMODEL">%1$s</xliff:g>"</string>
    <string name="select_device_name_description" msgid="8528185095614986580">"Jepi një emër pajisjes sate për të ndihmuar ta identifikosh atë kur transmeton ose kur lidhesh me të nga pajisjet e tjera."</string>
  <string-array name="rooms">
    <item msgid="6590829789532602097">"Android TV"</item>
    <item msgid="1140506340411482365">"Televizori i dhomës së ndenjjes"</item>
    <item msgid="6448060889026244632">"Televizori i dhomës familjare"</item>
    <item msgid="3336274213215419228">"Televizori i dhomës së gjumit"</item>
  </string-array>
    <string name="custom_room" msgid="6798144004583173563">"Fut një emër të personalizuar…"</string>
    <string name="device_rename_title" msgid="9070021379000499270">"Riemërtoje këtë pajisje <xliff:g id="DEVICEMODEL">%1$s</xliff:g>"</string>
    <string name="device_rename_description" msgid="1973894029492915135">"Kjo pajisje <xliff:g id="DEVICEMODEL">%1$s</xliff:g> është emërtuar aktualisht si \"<xliff:g id="DEVICENAME">%2$s</xliff:g>\""</string>
    <string name="device_name_suggestion_title" msgid="3986220212759193742">"Vendos emrin e pajisjes sate"</string>
    <string name="device_name_suggestion_summary" msgid="4582691399302362938">"Përdor këtë emër kur të transmetosh fotografi, video etj. nga telefoni yt"</string>
    <string name="change_setting" msgid="7211706374208138343">"Ndrysho"</string>
    <string name="keep_settings" msgid="703474489210093961">"Mos ndrysho"</string>
    <string name="apps_permissions" msgid="7876407267050498394">"Lejet"</string>
    <string name="device_apps_permissions" msgid="8421323706003063878">"Lejet e aplikacionit"</string>
    <string name="app_permissions_group_summary" msgid="6818210080117761117">"<xliff:g id="COUNT_0">%1$d</xliff:g> nga <xliff:g id="COUNT_1">%2$d</xliff:g> aplikacione të lejuara"</string>
    <string name="bluetooth_permission_request" msgid="7788089036741496993">"Kërkesa për leje për Bluetooth"</string>
    <string name="security_patch" msgid="8924741264829495392">"Niveli i korrigjimit të sigurisë së sistemit operativ të Android TV"</string>
    <string name="choose_application" msgid="2375936782103669988">"Zgjidh aplikacionin"</string>
    <string name="experimental_preference" msgid="3982593252210557436">"(Eksperimentale)"</string>
    <string name="reboot_safemode_action" msgid="2862127510492131128">"Rifillo në \"modalitetin e sigurisë\""</string>
    <string name="reboot_safemode_confirm" msgid="5745977150299953603">"Dëshiron që ta rindezësh në modalitetin e sigurt?"</string>
    <string name="reboot_safemode_desc" msgid="2919933461408942799">"Kjo do të çaktivizojë të gjitha aplikacionet e palëve të treta që ke instaluar. Ato do të restaurohen kur ta rindezësh përsëri."</string>
    <string name="capturing_bugreport" msgid="832512801903486821">"Raporti i defekteve në kod po regjistrohet"</string>
    <string name="available_virtual_keyboard_category" msgid="7445262027711560629">"Tastierat virtuale në dispozicion"</string>
    <string name="manage_keyboards" msgid="7983890675377321912">"Menaxho tastierat"</string>
    <string name="app_permission_summary_allowed" msgid="5359622119044147500">"Lejohet"</string>
    <string name="app_permission_summary_not_allowed" msgid="5131611341738385303">"Nuk lejohet"</string>
    <string name="usage_access" msgid="8402350645248312782">"Qasja te përdorimi"</string>
    <string name="usage_access_description" msgid="3276026988575551587">"Qasja te përdorimi lejon që një aplikacion të gjurmojë se çfarë përdorin aplikacionet e tjera dhe sa shpesh e përdorin, si edhe operatorin celular, cilësimet e gjuhës dhe detaje të tjera."</string>
    <string name="high_power_apps" msgid="5841073958519976562">"Optimizimi i energjisë"</string>
    <string name="high_power_apps_description" msgid="8651692364795060525">"Optimizo përdorimin e energjisë nga aplikacionet"</string>
    <string name="high_power_apps_empty" msgid="3084512758421482051">"Asnjë aplikacion nuk ka nevojë për optimizim"</string>
    <string name="high_power_on" msgid="3120162683093360951">"Jo të optimizuara"</string>
    <string name="high_power_off" msgid="3588854600942236231">"Optimizojnë përdorimin e energjisë"</string>
    <string name="high_power_system" msgid="6263052626979462255">"Optimizimi i energjisë nuk ofrohet"</string>
    <string name="manage_notification_access_title" msgid="8659254371564990084">"Qasja te njoftimet"</string>
    <string name="no_notification_listeners" msgid="5119406452675724448">"Asnjë apl. i instaluar nuk ka kërkuar qasje te njoftimet."</string>
    <string name="notification_listener_security_warning_summary" msgid="8602907284276088658">"Këto aplikacione do të jenë në gjendje të lexojnë të gjitha njoftimet, duke përfshirë informacione personale të tilla si emrat e kontakteve dhe tekstin e mesazheve që merr. Ato do të jenë po ashtu në gjendje t\'i heqin njoftimet ose të aktivizojnë butonat e veprimeve që përmbajnë."</string>
    <string name="default_notification_access_package_summary" msgid="1354775994781420222">"Kërkohet nga sistemi"</string>
    <string name="directory_access" msgid="7338555825237012006">"Qasja në direktori"</string>
    <string name="directory_access_description" msgid="3630855858552422012">"Këto aplikacione kanë leje për t\'u qasur në disa direktori të caktuara."</string>
    <string name="directory_on_volume" msgid="5628089584970521703">"<xliff:g id="VOLUME">%1$s</xliff:g> (<xliff:g id="DIRECTORY">%2$s</xliff:g>)"</string>
    <string name="system_alert_window_settings" msgid="5790572489650085051">"Shfaq mbi aplikacionet e tjera"</string>
    <string name="permit_draw_overlay" msgid="5312730681030266735">"Lejo shfaqjen mbi aplikacionet e tjera"</string>
    <string name="allow_overlay_description" msgid="5152329837278240259">"Lejo një aplikacion të shfaqet në krye të aplikacioneve të tjera që po përdor. Kjo mund të ndërhyjë me përdorimin tënd të atyre aplikacioneve ose mund të ndryshojë mënyrën se si ata duken ose sillen."</string>
    <string name="write_system_settings" msgid="4284654265954461890">"Modifiko cilësimet e sistemit"</string>
    <string name="write_settings_title" msgid="2361816483383105754">"Mund të modifikojë cilësimet e sistemit"</string>
    <string name="write_settings_description" msgid="7382397926674265937">"Ky autorizim e lejon një aplikacion të modifikojë cilësimet e sistemit"</string>
    <string name="write_settings_on" msgid="71675710746513956">"Po"</string>
    <string name="write_settings_off" msgid="6730113471695092167">"Jo"</string>
    <string name="manage_external_storage_title" msgid="8139593207533811077">"Qasje te të gjithë skedarët"</string>
    <string name="permit_manage_external_storage" msgid="1776899171934627417">"Lejo qasjen për të menaxhuar të gjithë skedarët"</string>
    <string name="allow_manage_external_storage_description" msgid="4288250228151617611">"Lejo që ky aplikacion të lexojë, modifikojë dhe fshijë të gjithë skedarët në këtë pajisje ose në çdo volum hapësire ruajtjeje të lidhur. Nëse lejohet, aplikacioni mund të ketë qasje te skedarët pa dijeninë tënde të qartë."</string>
    <string name="picture_in_picture_title" msgid="2636935591386702348">"Figurë brenda figurës"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="3688997906817583854">"Lejo figurë brenda figurës"</string>
    <string name="picture_in_picture_empty_text" msgid="4370198922852736600">"Asnjë aplikacion i instaluar nuk e mbështet figurën brenda figurës"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="3296649114939705896">"Lejo aplikacionet të krijojnë dritare \"figurë brenda figure\" ndërkohë që aplikacioni është i hapur ose pasi të dalësh prej tij (për shembull, për të vazhduar shikimin e një videoje). Kjo dritare shfaqet mbi aplikacionet e tjera që po përdor."</string>
    <string name="alarms_and_reminders_description" msgid="4063972350154624500">"Lejo që aplikacionet të caktojnë alarmet dhe të planifikojnë veprime që kanë një afat të caktuar. Kjo lejon që aplikacionet të ekzekutohen në sfond, gjë që mund të përdorë më shumë energji.\n\nNëse kjo leje është caktuar si joaktive, alarmet ekzistuese dhe ngjarjet me bazë kohore të planifikuara nga aplikacionet nuk do të funksionojnë."</string>
    <string name="turn_screen_on_title" msgid="5293798529284629011">"Ndiz ekranin"</string>
    <string name="allow_turn_screen_on" msgid="4903401106871656521">"Lejo ndezjen e ekranit"</string>
    <string name="allow_turn_screen_on_description" msgid="7521761625343889415">"Lejo një aplikacion të ndezë ekranin. Nëse lejohet, aplikacioni mund ta ndezë ekranin në çdo kohë pa synimin tënd të shprehur."</string>
    <string name="special_access" msgid="21806055758289916">"Qasja e veçantë e apl."</string>
    <string name="string_concat" msgid="5213870180216051497">"<xliff:g id="PART1">%1$s</xliff:g>, <xliff:g id="PART2">%2$s</xliff:g>"</string>
    <string name="audio_category" msgid="6143623109624947993">"Audioja"</string>
    <string name="record_audio" msgid="5035689290259575229">"Regjistro audion"</string>
    <string name="record_audio_summary_on" msgid="8724494646461335090">"Çaktivizoje që të ndalosh regjistrimin e audios"</string>
    <string name="record_audio_summary_off" msgid="1392440365091422816">"Aktivizoje që të fillosh në çast regjistrimin e audios"</string>
    <string name="play_recorded_audio_title" msgid="4627717067151602729">"Luaj audion e regjistruar"</string>
    <string name="save_recorded_audio_title" msgid="378003351782124651">"Ruaj audion e regjistruar"</string>
    <string name="time_to_start_read_title" msgid="6565449163802837806">"Koha deri në fillimin e leximit"</string>
    <string name="time_to_valid_audio_title" msgid="7246101824813414348">"Koha deri në të dhëna të vlefshme audio"</string>
    <string name="empty_audio_duration_title" msgid="9024377320171450683">"Kohëzgjatja e audios bosh"</string>
    <string name="record_audio_source_title" msgid="9087784503276397929">"Burimi i audios së regjistrimit"</string>
    <string name="record_audio_source_dialog_title" msgid="6556408220589197097">"Zgjidh burimin e audios për regjistrimin e radhës"</string>
    <string name="recorded_microphones_title" msgid="5466988146086215426">"Mikrofonat për regjistrimin"</string>
    <string name="show_audio_recording_start_failed" msgid="9131762831381326605">"Nisja e regjistrimit të audios dështoi."</string>
    <string name="show_audio_recording_failed" msgid="8128216664039868681">"Regjistrimi i audios dështoi."</string>
    <string name="bluetooth_ask_discovery_title" msgid="4955540555242269694">"Të bëhet e dukshme për pajisjet e tjera me Bluetooth?"</string>
    <string name="bluetooth_ask_discovery_message" msgid="8609666862877703398">"Një aplikacion kërkon ta bëjë televizorin tënd të dukshëm ndaj pajisjeve të tjera me Bluetooth për <xliff:g id="TIMEOUT">%1$d</xliff:g> sekonda."</string>
    <string name="help_center_title" msgid="6109822142761302433"></string>
    <string name="disabled_by_policy_title" msgid="2220484346213756472">"Veprimi nuk lejohet"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="4229779946666263271">"Volumi nuk mund të ndryshohet"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="8642280178608881544">"Telefonata nuk lejohet"</string>
    <string name="disabled_by_policy_title_sms" msgid="5721045390560951358">"Mesazhi SMS nuk lejohet"</string>
    <string name="disabled_by_policy_title_camera" msgid="6576557964422257426">"Kamera nuk lejohet"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="5774035841010091253">"Pamja e ekranit nuk lejohet"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="6500185610058872758">"Ky aplikacion nuk mund të hapet"</string>
    <string name="default_admin_support_msg" msgid="7913455019068370350">"Nëse ke pyetje, kontakto me administratorin e teknologjisë së informacionit"</string>
    <string name="admin_support_more_info" msgid="9053232166115098434">"Më shumë detaje"</string>
    <string name="admin_profile_owner_message" msgid="5729169873349157622">"Administratori yt mund të monitorojë dhe të menaxhojë aplikacionet dhe të dhënat e lidhura me profilin tënd të punës, duke përfshirë cilësimet, lejet, qasjen e korporatës, aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes."</string>
    <string name="admin_profile_owner_user_message" msgid="6431405126322617268">"Administratori yt mund të monitorojë dhe të menaxhojë aplikacionet dhe të dhënat e lidhura me këtë përdorues, duke përfshirë cilësimet, lejet, qasjen e korporatës, aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes."</string>
    <string name="admin_device_owner_message" msgid="1935507216776040907">"Administratori yt mund të monitorojë dhe menaxhojë aplikacionet dhe të dhënat e lidhura me këtë pajisje, duke përfshirë cilësimet, lejet, qasjen e korporatës, aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes."</string>
    <string name="remove_managed_profile_label" msgid="8950011141359605612">"Hiq profilin e punës"</string>
    <string name="active_device_admin_msg" msgid="185537304726228624">"Apl. i administrimit të pajisjes"</string>
    <string name="remove_device_admin" msgid="2623866073546295104">"Çaktivizo këtë aplikacion të administrimit të pajisjes"</string>
    <string name="uninstall_device_admin" msgid="6301368408620948266">"Çinstalo aplikacionin"</string>
    <string name="remove_and_uninstall_device_admin" msgid="1504351551194915633">"Çaktivizo dhe çinstalo"</string>
    <string name="select_device_admin_msg" msgid="8475934459999710332">"Apl. e admin. të pajisjes"</string>
    <string name="add_device_admin_msg" msgid="5390773166682603421">"Të aktivizohet apl. i admin. të pajisjes?"</string>
    <string name="add_device_admin" msgid="5078281377915844544">"Aktivizo këtë aplikacion të administrimit të pajisjes"</string>
    <string name="device_admin_warning" msgid="7399916080685200660">"Aktivizimi i këtij aplikacioni të administrimit do të lejojë që aplikacioni \"<xliff:g id="APP_NAME">%1$s</xliff:g>\" të kryejë veprimet e mëposhtme:"</string>
    <string name="device_admin_warning_simplified" msgid="3310965971422346950">"Kjo pajisje do të menaxhohet dhe do të monitorohet nga <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="5467001937240455367">"Ky aplikacion administrimi është aktiv dhe lejon apl. <xliff:g id="APP_NAME">%1$s</xliff:g> të kryejë veprimet e mëposhtme:"</string>
    <string name="adding_profile_owner_warning" msgid="3888867082224127564">"Duke vazhduar, profili yt si \"përdorues\" do të menaxhohet nga administratori yt, i cili mund të ruajë të dhënat e lidhura, përveç të dhënave të tua personale.\n\nAdministratori yt ka aftësinë që të monitorojë dhe të menaxhojë cilësimet, qasjen, aplikacionet dhe të dhënat e lidhura me këtë përdorues, duke përfshirë aktivitetin e rrjetit dhe informacionet e vendndodhjes së pajisjes tënde."</string>
    <string name="share_remote_bugreport_dialog_title" msgid="2080017987692459555">"Të ndahet raporti i defektit në kod?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="8515056665416643253">"Administratori i teknologjisë së informacionit kërkoi një raport të defekteve në kod për të ndihmuar me zgjidhjen e problemeve. Aplikacioni dhe të dhënat mund të ndahen."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="4637489112422692638">"Administratori i teknologjisë së informacionit kërkoi një raport të defekteve në kod për të ndihmuar me zgjidhjen e problemeve. Aplikacioni dhe të dhënat mund të ndahen dhe kjo mund të ngadalësojë përkohësisht pajisjen tënde."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="8096239263583331293">"Ky raport i defektit në kod po ndahet me administratorin tënd të IT-së. Kontaktoje atë për më shumë detaje."</string>
    <string name="share_remote_bugreport_action" msgid="6760197666368262892">"Ndaj"</string>
    <string name="decline_remote_bugreport_action" msgid="2130779396296090961">"Refuzo"</string>
    <string name="network_connection_request_dialog_title" msgid="4103963119407212989">"Pajisja që do të përdoret me <xliff:g id="APPNAME">%1$s</xliff:g>"</string>
    <string name="network_connection_timeout_dialog_message" msgid="8408857135950230472">"Nuk u gjet asnjë pajisje. Sigurohu që pajisjet të jenë të ndezura dhe të gatshme për t\'u lidhur."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="5374522862360880609">"Provo sërish"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3346121178275518630">"Ndodhi diçka. Aplikacioni ka anuluar kërkesën për të zgjedhur një pajisje."</string>
    <string name="network_connection_connect_successful" msgid="2981223044343511313">"Lidhja ishte e suksesshme"</string>
    <string name="network_connection_request_dialog_showall" msgid="2653775399674126208">"Shfaq të gjitha"</string>
    <string name="progress_scanning" msgid="3323638586482686516">"Po kërkon"</string>
    <string name="add_account_intent_not_available_dialog_message" msgid="8326403834567215053">"Synimi i llogarisë së reklamës nuk u mor nga vërtetuesi."</string>
    <string name="add_account_failed_dialog_message" msgid="3704858007957373186">"Llogaria nuk u shtua ose lloji i llogarisë nuk ofrohet."</string>
    <string name="channels_and_inputs_title" msgid="7484506121290830217">"Kanalet dhe hyrjet"</string>
    <string name="channels_and_inputs_summary" msgid="3168386051698084007">"Kanalet, hyrjet e jashtme"</string>
    <string name="channels_settings_title" msgid="8048956665383762510">"Kanale"</string>
    <string name="external_inputs_settings_title" msgid="8937038060355986380">"Hyrjet e jashtme"</string>
    <string name="display_and_sound_vendor_summary" msgid="7661072343315403110">"Figura, ekrani, tingulli"</string>
    <string name="picture_settings_title" msgid="7643193630924322697">"Figura"</string>
    <string name="screen_settings_title" msgid="7806908869190824434">"Ekrani"</string>
    <string name="sound_settings_title" msgid="9149367966117889465">"Tingulli"</string>
    <string name="power_and_energy" msgid="4638182439670702556">"Fuqia dhe energjia"</string>
    <string name="power_on_behavior" msgid="927607372303160716">"Sjellja pas ndezjes"</string>
    <string name="reset_options_title" msgid="7632580482285108955">"Rivendos"</string>
    <string name="system_tv_title" msgid="2800695543185187197">"Televizori"</string>
    <string name="adb_pairing_device_dialog_ethernet_pairing_code_label" msgid="7551782499828944838">"Kodi i çiftimit i ethernet-it"</string>
    <string name="energy_modes" msgid="1331693860386361744">"Modalitetet e energjisë"</string>
    <string name="energy_modes_summary" msgid="2324906343309484649">"Këto cilësime kanë ndikim te pajisja kur ajo nuk është në përdorim"</string>
    <string name="energy_mode_enables" msgid="357960364751477627">"Aktivizon:"</string>
    <string name="energy_mode_eco_hint" msgid="5280058011809503514">"Konsumi i energjisë mund të rritet me numrin e veçorive të televizorit që aktivizon ti."</string>
    <string name="energy_modes_confirmation_title" msgid="4520280098781914825">"Aktivizo \"<xliff:g id="ENERGYMODENAME">%s</xliff:g>\""</string>
    <string name="settings_find_my_remote_title" msgid="4586368268611622848">"Gjej telekomandën time"</string>
    <string name="settings_find_my_remote_description" msgid="6606011378441585154">"Luaj një tingull për të gjetur telekomandën e Google TV nëse ke harruar se ku e ke vendosur"</string>
    <string name="find_my_remote_slice_description" msgid="313598681990933215">"Ka një buton në Google TV që mund ta shtypësh për të luajtur një tingull në telekomandë për 30 sekonda. Kjo funksionon vetëm me telekomanda të mbështetura të Google TV.\n\nPër të ndaluar tingullin, shtyp cilindo buton në telekomandë."</string>
    <string name="find_my_remote_integration_hint" msgid="1505908080631286111">"Kur kjo është aktive, mund të përdorësh butonin në pajisjen tënde për të luajtur një tingull për të lokalizuar telekomandën tënde. Kur kjo është joaktive, ky buton nuk do të funksionojë. Do të mund ta përdorësh përsëri \"Gjej telekomandën\" nëpërmjet metodave të tjera."</string>
    <string name="find_my_remote_play_sound" msgid="3364983972397728084">"Luaj tingullin"</string>
    <string name="volume_change_settings_title" msgid="7861540652599113353">"Volumi i %1$s"</string>
    <string name="volume_change_subtitle_unselect" msgid="7419217244526249839">"Mund ta kontrollosh volumin e \"Asistentit\" në altoparlantin e %1$s"</string>
    <string name="volume_change_subtitle_select" msgid="357283268411175266">"Prek vetëm volumin në pajisjen %1$s, jo në televizor"</string>
</resources>
