<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="kilobyteShort" msgid="5973789783504771878">"KB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="9164292791500531949">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="durationDays" msgid="6652371460511178259">"<xliff:g id="DAYS">%1$d</xliff:g> dni"</string>
    <string name="durationDayHours" msgid="2713107458736744435">"<xliff:g id="DAYS">%1$d</xliff:g> dzień <xliff:g id="HOURS">%2$d</xliff:g> godz."</string>
    <string name="durationDayHour" msgid="7293789639090958917">"<xliff:g id="DAYS">%1$d</xliff:g> dzień <xliff:g id="HOURS">%2$d</xliff:g> godz."</string>
    <string name="durationHours" msgid="4266858287167358988">"<xliff:g id="HOURS">%1$d</xliff:g> godz."</string>
    <string name="durationHourMinutes" msgid="9029176248692041549">"<xliff:g id="HOURS">%1$d</xliff:g> godz. <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="durationHourMinute" msgid="2741677355177402539">"<xliff:g id="HOURS">%1$d</xliff:g> godz. <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="durationMinutes" msgid="3134226679883579347">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="durationMinute" msgid="7155301744174623818">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="durationMinuteSeconds" msgid="1424656185379003751">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="durationMinuteSecond" msgid="3989228718067466680">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="durationSeconds" msgid="8050088505238241405">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="durationSecond" msgid="985669622276420331">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Bez nazwy&gt;"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Brak numeru telefonu)"</string>
    <string name="unknownName" msgid="6867811765370350269">"Nieznana"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Poczta głosowa"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Problem z połączeniem lub błędny kod MMI."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Operacja jest ograniczona wyłącznie do numerów ustalonych."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Usługa została włączona."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Usługa została włączona dla:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Usługa została wyłączona."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Rejestracja powiodła się."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Wymazywanie zakończone pomyślnie."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Błędne hasło."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI zakończone."</string>
    <string name="badPin" msgid="9015277645546710014">"Wpisany stary kod PIN jest nieprawidłowy."</string>
    <string name="badPuk" msgid="5487257647081132201">"Wprowadzony kod PUK jest nieprawidłowy."</string>
    <string name="mismatchPin" msgid="609379054496863419">"Wpisane kody PIN nie są identyczne."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Wpisz kod PIN o długości od 4 do 8 cyfr."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Wpisz kod PUK składający się z co najmniej 8 cyfr."</string>
    <string name="needPuk" msgid="919668385956251611">"Karta SIM jest zablokowana kodem PUK. Wprowadź kod PUK, aby odblokować kartę."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Wprowadź kod PUK2, aby odblokować kartę SIM."</string>
    <string name="enablePin" msgid="209412020907207950">"Nie udało się. Włącz blokadę karty SIM/RUIM."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1251012001539225582">
      <item quantity="few">Masz jeszcze <xliff:g id="NUMBER_1">%d</xliff:g> próby, zanim karta SIM zostanie zablokowana.</item>
      <item quantity="many">Masz jeszcze <xliff:g id="NUMBER_1">%d</xliff:g> prób, zanim karta SIM zostanie zablokowana.</item>
      <item quantity="other">Masz jeszcze <xliff:g id="NUMBER_1">%d</xliff:g> próby, zanim karta SIM zostanie zablokowana.</item>
      <item quantity="one">Masz jeszcze <xliff:g id="NUMBER_0">%d</xliff:g> próbę, zanim karta SIM zostanie zablokowana.</item>
    </plurals>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Nazwa rozmówcy przy połączeniach przychodzących"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Nazwa rozmówcy przy połączeniach wychodzących"</string>
    <string name="ColpMmi" msgid="3065121483740183974">"Identyfikator połączonej linii"</string>
    <string name="ColrMmi" msgid="4996540314421889589">"Ograniczenie identyfikatora połączonej linii"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Przekierowanie połączeń"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Połączenia oczekujące"</string>
    <string name="BaMmi" msgid="455193067926770581">"Blokada dzwonienia"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Zmiana hasła"</string>
    <string name="PinMmi" msgid="3113117780361190304">"Zmiana kodu PIN"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Numer telefonu, z którego wykonywane jest połączenie, widoczny"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Numer telefonujący zastrzeżony"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Połączenie dla trzech abonentów"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Odrzucanie niepożądanych, irytujących połączeń"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Dostarczanie numeru telefonującego"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Nie przeszkadzać"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Nazwa rozmówcy ustawiona jest domyślnie na „zastrzeżony”. Następne połączenie: zastrzeżony"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Nazwa rozmówcy ustawiona jest domyślnie na „zastrzeżony”. Następne połączenie: nie zastrzeżony"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Nazwa rozmówcy ustawiona jest domyślnie na „nie zastrzeżony”. Następne połączenie: zastrzeżony"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Nazwa rozmówcy ustawiona jest domyślnie na „nie zastrzeżony”. Następne połączenie: nie zastrzeżony"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Usługa nie jest świadczona."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Nie możesz zmienić ustawienia identyfikatora rozmówcy."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Zmieniono ograniczenie dostępu"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Usługa transmisji danych jest zablokowana."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Usługa połączeń alarmowych jest zablokowana."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Usługa głosowa jest zablokowana."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Wszystkie usługi głosowe są zablokowane."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"Usługa SMS jest zablokowana."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Usługi głosowe/danych są zablokowane."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Usługi głosowe/SMS są zablokowane."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Wszystkie usługi głosowe/danych/SMS są zablokowane."</string>
    <string name="peerTtyModeFull" msgid="6165351790010341421">"Drugie urządzenie zażądało trybu „TTY pełny”"</string>
    <string name="peerTtyModeHco" msgid="5728602160669216784">"Drugie urządzenie zażądało trybu „TTY HCO”"</string>
    <string name="peerTtyModeVco" msgid="1742404978686538049">"Drugie urządzenie zażądało trybu „TTY VCO”"</string>
    <string name="peerTtyModeOff" msgid="3280819717850602205">"Drugie urządzenie zażądało trybu „TTY wyłączony”"</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Głos"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Dane"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAKS"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Dane asynchroniczne"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Synchronizacja"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Pakiet"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Wskaźnik roamingu włączony"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Wskaźnik roamingu wyłączony"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Migający wskaźnik roamingu"</string>
    <string name="roamingText3" msgid="5148255027043943317">"W innej okolicy"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Poza biurem"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming – preferowany system"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming – dostępny system"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Roaming – partner stowarzyszony"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Roaming – partner Premium"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Roaming – pełna funkcjonalność usługi"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Roaming – częściowa funkcjonalność usługi"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Baner roamingu włączony"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Baner roamingu wyłączony"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Wyszukiwanie usługi"</string>
    <string name="wfcRegErrorTitle" msgid="2301376280632110664">"Połączenia przez Wi-Fi"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
  </string-array>
    <string name="wfcSpnFormat" msgid="8211621332478306568">"%s"</string>
    <string name="wfcDataSpnFormat" msgid="1118052028767666883">"%s"</string>
    <string name="wifi_calling_off_summary" msgid="8720659586041656098">"Wył."</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1994113411286935263">"Preferuj Wi-Fi"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="5920549484600758786">"Preferuj sieć komórkową"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="2379919155237869320">"Tylko Wi-Fi"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: nieprzekierowane"</string>
    <string name="cfTemplateForwarded" msgid="1302922117498590521">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="9206251736527085256">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> po <xliff:g id="TIME_DELAY">{2}</xliff:g> sekundach"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: nieprzekierowane"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: nieprzekierowane"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Wykonano kod funkcji."</string>
    <string name="fcError" msgid="3327560126588500777">"Problem z połączeniem lub nieprawidłowy kod funkcji."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"OK"</string>
    <string name="httpError" msgid="7956392511146698522">"Wystąpił błąd sieci."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Nie można znaleźć URL-a."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Schemat uwierzytelniania witryny nie jest obsługiwany."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Nie można uwierzytelnić."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Autoryzacja przez serwer proxy zakończyła się niepowodzeniem."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Nie można nawiązać połączenia z serwerem."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Nie można nawiązać połączenia z serwerem. Spróbuj ponownie później."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Zbyt długi czas oczekiwania na połączenie z serwerem."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Strona zawiera zbyt wiele przekierowań do serwerów."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokół nie jest obsługiwany."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Nie można ustanowić bezpiecznego połączenia."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Nie można otworzyć strony, ponieważ URL jest nieprawidłowy."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Nie można uzyskać dostępu do pliku."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Nie można znaleźć żądanego pliku."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Zbyt wiele żądań jest przetwarzanych. Spróbuj ponownie później."</string>
    <string name="notification_title" msgid="8967710025036163822">"Błąd logowania na konto <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Synchronizacja"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Synchronizuj"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Zbyt wiele usuwanych <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Pamięć tabletu jest pełna. Usuń niektóre pliki, aby zwolnić miejsce."</string>
    <string name="low_memory" product="watch" msgid="4415914910770005166">"Pamięć w zegarku jest pełna. Usuń niektóre pliki, by zwolnić miejsce."</string>
    <string name="low_memory" product="tv" msgid="516619861191025923">"Pamięć telewizora jest pełna. Usuń jakieś pliki, by zwolnić miejsce."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Pamięć telefonu jest pełna. Usuń niektóre pliki, aby zwolnić miejsce."</string>
    <string name="ssl_ca_cert_warning" msgid="5848402127455021714">"Sieć może być monitorowana"</string>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"Przez nieznany podmiot zewnętrzny"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="550758088185764312">"Przez administratora Twojego profilu do pracy"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"Przez <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5005572078641980632">"Usunięto profil do pracy"</string>
    <string name="work_profile_deleted_description" msgid="6305147513054341102">"Profil do pracy został usunięty z powodu braku aplikacji administracyjnej."</string>
    <string name="work_profile_deleted_details" msgid="226615743462361248">"Brakuje aplikacji administracyjnej profilu do pracy lub jest ona uszkodzona. Z tego powodu Twój profil do pracy i związane z nim dane zostały usunięte. Skontaktuj się ze swoim administratorem, by uzyskać pomoc."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="6019770344820507579">"Twój profil do pracy nie jest już dostępny na tym urządzeniu."</string>
    <string name="factory_reset_warning" msgid="5423253125642394387">"Twoje urządzenie zostanie wyczyszczone"</string>
    <string name="factory_reset_message" msgid="4905025204141900666">"Aplikacja administracyjna nie ma wszystkich składników lub jest uszkodzona i nie można jej użyć. Twoje urządzenie zostanie teraz wyczyszczone. Skontaktuj się ze swoim administratorem, aby uzyskać pomoc."</string>
    <string name="me" msgid="6545696007631404292">"Ja"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Opcje tabletu"</string>
    <string name="power_dialog" product="tv" msgid="6153888706430556356">"Opcje telewizora"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Opcje telefonu"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Tryb cichy"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Włącz połączenia bezprzewodowe"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Wyłącz połączenia bezprzewodowe"</string>
    <string name="screen_lock" msgid="799094655496098153">"Blokada ekranu"</string>
    <string name="power_off" msgid="4266614107412865048">"Wyłącz"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Dzwonek wyłączony"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Dzwonek z wibracjami"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Dzwonek włączony"</string>
    <string name="reboot_to_update_title" msgid="6212636802536823850">"Aktualizacja systemu Android"</string>
    <string name="reboot_to_update_prepare" msgid="6305853831955310890">"Przygotowuję do aktualizacji…"</string>
    <string name="reboot_to_update_package" msgid="3871302324500927291">"Przetwarzam pakiet aktualizacji…"</string>
    <string name="reboot_to_update_reboot" msgid="6428441000951565185">"Uruchamiam ponownie…"</string>
    <string name="reboot_to_reset_title" msgid="4142355915340627490">"Przywracanie danych fabrycznych"</string>
    <string name="reboot_to_reset_message" msgid="2432077491101416345">"Uruchamiam ponownie…"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Wyłączanie..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Tablet zostanie wyłączony."</string>
    <string name="shutdown_confirm" product="tv" msgid="476672373995075359">"Telewizor zostanie wyłączony."</string>
    <string name="shutdown_confirm" product="watch" msgid="3490275567476369184">"Zegarek zostanie wyłączony."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Telefon zostanie wyłączony"</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Czy chcesz wyłączyć?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Uruchom w trybie awaryjnym"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Chcesz uruchomić urządzenie w trybie awaryjnym? W ten sposób wyłączysz wszystkie zainstalowane aplikacje innych firm. Zostaną one przywrócone po ponownym uruchomieniu."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Najnowsze"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Brak ostatnio uruchomionych aplikacji."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Opcje tabletu"</string>
    <string name="global_actions" product="tv" msgid="7240386462508182976">"Opcje telewizora"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Opcje telefonu"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Blokada ekranu"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Wyłącz"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Zgłoszenie błędu"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Zgłoś błąd"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Informacje o bieżącym stanie urządzenia zostaną zebrane i wysłane e-mailem. Przygotowanie zgłoszenia błędu do wysłania chwilę potrwa, więc zachowaj cierpliwość."</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Tryb cichy"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Dźwięk jest wyłączony"</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Dźwięk jest włączony"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Tryb samolotowy"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Tryb samolotowy jest włączony"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Tryb samolotowy jest wyłączony"</string>
    <string name="global_action_settings" msgid="1756531602592545966">"Ustawienia"</string>
    <string name="global_action_assist" msgid="3892832961594295030">"Pomoc"</string>
    <string name="global_action_voice_assist" msgid="7751191495200504480">"Asystent głosowy"</string>
    <string name="global_action_lockdown" msgid="8751542514724332873">"Zablokuj teraz"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"&gt;999"</string>
    <string name="safeMode" msgid="2788228061547930246">"Tryb awaryjny"</string>
    <string name="android_system_label" msgid="6577375335728551336">"System Android"</string>
    <string name="user_owner_label" msgid="6465364741001216388">"Aplikacje osobiste"</string>
    <string name="managed_profile_label" msgid="6260850669674791528">"Praca"</string>
    <string name="permgrouplab_contacts" msgid="3657758145679177612">"Kontakty"</string>
    <string name="permgroupdesc_contacts" msgid="6951499528303668046">"dostęp do kontaktów"</string>
    <string name="permgrouplab_location" msgid="7275582855722310164">"Lokalizacja"</string>
    <string name="permgroupdesc_location" msgid="1346617465127855033">"dostęp do lokalizacji tego urządzenia"</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Twoje informacje społecznościowe"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Bezpośredni dostęp do informacji o Twoich kontaktach i powiązaniach społecznościowych."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendarz"</string>
    <string name="permgroupdesc_calendar" msgid="3889615280211184106">"dostęp do kalendarza"</string>
    <string name="permgrouplab_sms" msgid="228308803364967808">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="4656988620100940350">"wysyłać i wyświetlać SMS-y"</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Pamięć"</string>
    <string name="permgroupdesc_storage" msgid="637758554581589203">"uzyskiwać dostęp do zdjęć, multimediów i plików na Twoim urządzeniu"</string>
    <string name="permgrouplab_dictionary" msgid="8114410334955871144">"Słownik użytkownika"</string>
    <string name="permgroupdesc_dictionary" msgid="7586787746354378335">"Odczytywanie lub zapisywanie słów w słowniku użytkownika."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Zakładki i historia"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Bezpośredni dostęp do zakładek i historii przeglądarki."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofon"</string>
    <string name="permgroupdesc_microphone" msgid="4988812113943554584">"nagrywanie dźwięku"</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Aparat"</string>
    <string name="permgroupdesc_camera" msgid="3250611594678347720">"robienie zdjęć i nagrywanie filmów"</string>
    <string name="permgrouplab_phone" msgid="5229115638567440675">"Telefon"</string>
    <string name="permgroupdesc_phone" msgid="6234224354060641055">"nawiązywanie połączeń telefonicznych i zarządzanie nimi"</string>
    <string name="permgrouplab_sensors" msgid="7416703484233940260">"Czujniki"</string>
    <string name="permgroupdesc_sensors" msgid="2280821510554029577">"uzyskiwać dostęp do informacji o podstawowych funkcjach Twojego organizmu i Twojej aktywności fizycznej"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Pobieranie zawartości okna"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Sprawdzanie zawartości okna, z którego korzystasz."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Włączenie czytania dotykiem"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Klikane elementy będą wymawiane na głos, a ekran można przeglądać, używając gestów."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Włączenie ułatwień dostępu w internecie"</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Można zainstalować skrypty, by zawartość aplikacji była łatwiej dostępna."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Obserwowanie wpisywanego tekstu"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Obejmuje informacje osobiste, takie jak numery kart kredytowych i hasła."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"wyłączanie lub zmienianie paska stanu"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Pozwala aplikacji na wyłączanie paska stanu oraz dodawanie i usuwanie ikon systemowych."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"pasek stanu"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Pozwala aplikacji na występowanie na pasku stanu."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"rozwijanie/zwijanie paska stanu"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Pozwala aplikacji na rozwijanie lub zwijanie paska stanu."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"instalowanie skrótów"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Pozwala aplikacji dodawać skróty na ekranie głównym bez interwencji użytkownika."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"odinstalowywanie skrótów"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"Pozwala aplikacji usuwać skróty z ekranu głównego bez interwencji użytkownika."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"przekierowywanie połączeń wychodzących"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5156385005547315876">"Pozwala aplikacji na sprawdzenie numeru wybieranego w trakcie połączenia wychodzącego, a także umożliwia przerwanie połączenia lub przekierowanie go pod inny numer."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"odbieranie wiadomości tekstowych (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Pozwala aplikacji na odbieranie i przetwarzanie SMS-ów. To oznacza, że aplikacja będzie mogła bez Twojej wiedzy monitorować i usuwać wiadomości wysyłane do Twojego urządzenia."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"odbieranie wiadomości tekstowych (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Pozwala aplikacji na odbieranie i przetwarzanie MMS-ów. To oznacza, że aplikacja będzie mogła bez Twojej wiedzy monitorować i usuwać wiadomości wysyłane do Twojego urządzenia."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"odczyt komunikatów z sieci komórkowej"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Zezwala aplikacji na odczyt komunikatów z sieci komórkowej odebranych na urządzeniu. Komunikaty alarmowe z sieci komórkowej są dostarczane w niektórych lokalizacjach w celu ostrzeżenia Cię o sytuacjach zagrożenia. Złośliwe aplikacje mogą wpływać na wydajność lub zakłócać działanie urządzenia po odebraniu komunikatu alarmowego z sieci komórkowej."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Twoje konta"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Dostęp do udostępnionych kont."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"czytanie subskrybowanych źródeł"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Pozwala aplikacji na pobieranie szczegółowych informacji na temat obecnie zsynchronizowanych kanałów."</string>
    <string name="permlab_sendSms" msgid="7544599214260982981">"wysyłać i wyświetlać SMS-y"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Pozwala aplikacji na wysyłanie SMS-ów. Może to skutkować nieoczekiwanymi opłatami. Złośliwe aplikacje mogą generować koszty, wysyłając wiadomości bez Twojego potwierdzenia."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"odczytywanie wiadomości tekstowych (SMS i MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Pozwala aplikacji na odczyt SMS-ów zapisanych na tablecie lub na karcie SIM. Aplikacja z tym uprawnieniem może czytać wszystkie SMS-y niezależnie od ich treści lub poufności."</string>
    <string name="permdesc_readSms" product="tv" msgid="5102425513647038535">"Pozwala aplikacji odczytywać SMS-y zapisane na telewizorze lub karcie SIM. Umożliwia to aplikacji odczytanie wszystkich SMS-ów, niezależnie od ich treści czy poufności."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Pozwala aplikacji na odczyt SMS-ów zapisanych na telefonie lub na karcie SIM. Aplikacja z tym uprawnieniem może czytać wszystkie SMS-y niezależnie od ich treści lub poufności."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"odbieranie wiadomości tekstowych (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Pozwala aplikacji na odbieranie i przetwarzanie wiadomości WAP. To oznacza, że aplikacja będzie mogła bez Twojej wiedzy monitorować i usuwać wiadomości wysyłane do Twojego urządzenia."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"pobieranie uruchomionych aplikacji"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Pozwala aplikacji na pobieranie informacji o aktualnie i niedawno działających zadaniach. Dzięki temu aplikacja może uzyskać informacje o tym, które aplikacje są używane na urządzeniu."</string>
    <string name="permlab_manageProfileAndDeviceOwners" msgid="5979288447973722097">"Zarządzanie właścicielami profilu i urządzenia"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="106894851498657169">"Zezwala aplikacjom na ustawianie właścicieli profilu i urządzenia."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"zmienianie kolejności uruchomionych aplikacji"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Pozwala aplikacji na przenoszenie zadań między tłem a pierwszym planem. Aplikacja może to robić bez Twojego udziału."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"włączanie trybu samochodowego"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Pozwala aplikacji na włączanie trybu samochodowego."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"zamykanie innych aplikacji"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Pozwala aplikacji na kończenie procesów innych aplikacji działających w tle. Może to spowodować przerwanie działania innych aplikacji."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"rysowanie na innych aplikacjach"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Zezwala aplikacji na wyświetlanie elementów interfejsu nad innymi aplikacjami lub elementami ich interfejsu. Może to powodować zakłócenia w korzystaniu z interfejsu innej aplikacji lub inne działanie aplikacji, niż wynikałoby to z widocznego interfejsu danej aplikacji."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"sprawianie, że aplikacja jest cały czas uruchomiona"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Pozwala aplikacji na trwałe zapisywanie swoich fragmentów w pamięci. Może to zmniejszyć ilość pamięci dostępnej dla innych aplikacji i spowolnić działanie tabletu."</string>
    <string name="permdesc_persistentActivity" product="tv" msgid="5086862529499103587">"Pozwala aplikacji zapewnić nieusuwalność swoich fragmentów z pamięci. Może to ograniczyć ilość pamięci dostępną dla innych aplikacji i spowalniać działanie telewizora."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Pozwala aplikacji na trwałe zapisywanie swoich fragmentów w pamięci. Może to zmniejszyć ilość pamięci dostępnej dla innych aplikacji i spowolnić działanie telefonu."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"mierzenie rozmiaru pamięci aplikacji"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Pozwala aplikacji na pobieranie własnego kodu, danych oraz rozmiarów pamięci podręcznej."</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"modyfikowanie ustawień systemu"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Pozwala aplikacji na zmienianie ustawień systemu. Złośliwe aplikacje mogą uszkodzić konfigurację systemu."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"uruchamianie podczas włączania urządzenia"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Pozwala aplikacji na uruchamianie się natychmiast po zakończeniu rozruchu systemu. Może to spowodować wydłużenie czasu uruchamiania tabletu oraz spowolnienie jego pracy przez zawsze działającą aplikację."</string>
    <string name="permdesc_receiveBootCompleted" product="tv" msgid="4525890122209673621">"Pozwala aplikacji na uruchamianie się zaraz po zakończeniu rozruchu systemu. Może to wydłużać czas uruchamiania telewizora i spowalniać całe jego działanie przez to, że będzie ona cały czas uruchomiona."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Pozwala aplikacji na uruchamianie się natychmiast po zakończeniu rozruchu systemu. Może to spowodować wydłużenie czasu uruchamiania telefonu oraz spowolnienie jego pracy przez zawsze działającą aplikację."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"wysyłanie transmisji trwałej"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Pozwala aplikacji na wysyłanie transmisji trwałych, które pozostają aktywne po zakończeniu połączenia. Nadmierne używanie może spowolnić lub zdestabilizować tablet przez wymuszenie zbyt dużego użycia pamięci."</string>
    <string name="permdesc_broadcastSticky" product="tv" msgid="6839285697565389467">"Pozwala aplikacji na wysyłanie trwałych transmisji, które są zachowywane po ich zakończeniu. Nadmierne wykorzystywanie może powodować wolne lub niestabilne działanie telewizora z powodu zajęcia zbyt dużej ilości pamięci."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Pozwala aplikacji na wysyłanie transmisji trwałych, które pozostają aktywne po zakończeniu połączenia. Nadmierne używanie może spowolnić lub zdestabilizować telefon przez wymuszenie zbyt dużego użycia pamięci."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"odczytywanie kontaktów"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Pozwala aplikacji na odczyt danych o kontaktach zapisanych na tablecie, w tym informacji o częstotliwości rozmawiania, przesyłania e-maili i komunikowania się w inny sposób z poszczególnymi osobami. Aplikacje z tym uprawnieniem mogą zapisywać dane kontaktów, a złośliwe aplikacje mogą je udostępniać bez Twojej wiedzy."</string>
    <string name="permdesc_readContacts" product="tv" msgid="1839238344654834087">"Pozwala aplikacji odczytywać zapisane na telewizorze dane o Twoich kontaktach, w tym jak często dzwonisz lub piszesz e-maile do określonych osób albo komunikujesz się z nimi na inne sposoby. To uprawnienie umożliwia aplikacjom zapisywanie danych Twoich kontaktów, a złośliwe aplikacje mogą przekazywać te dane bez Twojej wiedzy."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Pozwala aplikacji na odczyt danych o kontaktach zapisanych na telefonie, w tym informacji o częstotliwości rozmawiania, przesyłania e-maili i komunikowania się w inny sposób z poszczególnymi osobami. Aplikacje z tym uprawnieniem mogą zapisywać dane kontaktów, a złośliwe aplikacje mogą je udostępniać bez Twojej wiedzy."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"modyfikowanie kontaktów"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Pozwala aplikacji na modyfikowanie danych o kontaktach zapisanych na tablecie, w tym informacji o częstotliwości rozmawiania, przesyłania e-maili i komunikowania się w inny sposób z poszczególnymi kontaktami. Aplikacje z tym uprawnieniem mogą usuwać dane kontaktów."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="5438230957000018959">"Pozwala aplikacji modyfikować dane o Twoich kontaktach zapisane na telewizorze, w tym jak często dzwonisz lub piszesz e-maile do określonych osób albo komunikujesz się z nimi na inne sposoby. To uprawnienie umożliwia aplikacjom usuwanie danych kontaktów."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Pozwala aplikacji na modyfikowanie danych o kontaktach zapisanych na telefonie, w tym informacji o częstotliwości rozmawiania, przesyłania e-maili i komunikowania się w inny sposób z poszczególnymi kontaktami. Aplikacje z tym uprawnieniem mogą usuwać dane kontaktów."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"czytanie rejestru połączeń"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Pozwala aplikacji na odczyt rejestru połączeń w tablecie, w tym danych o połączeniach przychodzących i wychodzących. Aplikacje z tym uprawnieniem mogą zapisywać dane z rejestru połączeń, a złośliwe aplikacje mogą je udostępniać bez Twojej wiedzy."</string>
    <string name="permdesc_readCallLog" product="tv" msgid="5611770887047387926">"Pozwala aplikacji odczytywać rejestr połączeń telewizora, w tym dane o połączeniach przychodzących i wychodzących. To uprawnienie umożliwia aplikacjom zapisywanie danych z rejestru połączeń, a szkodliwe aplikacje mogą przekazywać te dane bez Twojej wiedzy."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Pozwala aplikacji na odczyt rejestru połączeń w telefonie, w tym danych o połączeniach przychodzących i wychodzących. Aplikacje z tym uprawnieniem mogą zapisywać dane z rejestru połączeń, a złośliwe aplikacje mogą je udostępniać bez Twojej wiedzy."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"zapisywanie rejestru połączeń"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Zezwala aplikacji na modyfikowanie rejestru połączeń tabletu, w tym danych o połączeniach przychodzących i wychodzących. Złośliwe aplikacje mogą wykorzystać tę możliwość, by wyczyścić lub zmodyfikować rejestr połączeń."</string>
    <string name="permdesc_writeCallLog" product="tv" msgid="4225034892248398019">"Pozwala aplikacji modyfikować rejestr połączeń telewizora, w tym dane o połączeniach przychodzących i wychodzących. Szkodliwe aplikacje mogą to wykorzystać do skasowania lub zmodyfikowania rejestru połączeń."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Zezwala aplikacji na modyfikowanie rejestru połączeń telefonu, w tym danych o połączeniach przychodzących i wychodzących. Złośliwe aplikacje mogą wykorzystać tę możliwość, by wyczyścić lub zmodyfikować rejestr połączeń."</string>
    <string name="permlab_readProfile" msgid="4701889852612716678">"odczytywanie własnej karty kontaktu"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Pozwala aplikacji na odczyt osobistych informacji przechowywanych w Twoim profilu na urządzeniu (np. imienia i nazwiska lub adresu). Oznacza to, że aplikacja może Cię zidentyfikować i wysłać informacje z Twojego profilu do innych osób."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"zmiana własnej karty kontaktu"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Pozwala aplikacji na zmianę lub dodanie osobistych informacji przechowywanych w Twoim profilu na urządzeniu (np. imienia i nazwiska lub adresu). Oznacza to, że aplikacja może Cię zidentyfikować i wysłać informacje z Twojego profilu do innych osób."</string>
    <string name="permlab_bodySensors" msgid="4871091374767171066">"czujniki ciała (np. monitorujące tętno)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="4380015021754180431">"Pozwala aplikacji na dostęp do danych z czujników, które monitorują Twój stan fizyczny (np. tętno)."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"odczyt sieci społecznościowych"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Pozwala aplikacji na odczyt i synchronizację informacji publikowanych przez Ciebie i Twoich znajomych w sieciach społecznościowych. Zachowaj ostrożność, udostępniając informacje. Aplikacja z tym uprawnieniem może odczytać całą komunikację, którą prowadzisz ze swoimi znajomymi w sieciach społecznościowych, niezależnie od jej poufności. Uwaga: to uprawnienie może nie być egzekwowane we wszystkich sieciach społecznościowych."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"zapis sieci społecznościowych"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Pozwala aplikacji na wyświetlanie informacji publikowanych przez Twoich znajomych w sieciach społecznościowych. Zachowaj ostrożność, udostępniając informacje. Aplikacja z tym uprawnieniem może tworzyć wiadomości, które wyglądają jakby pochodziły od znajomych. Uwaga: to uprawnienie może nie być egzekwowane we wszystkich sieciach społecznościowych."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"odczyt wydarzeń w kalendarzu wraz z informacjami poufnymi"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Pozwala aplikacji  na odczytywanie wszystkich wydarzeń w kalendarzu zapisanych na tablecie, w tym pochodzących od znajomych i współpracowników. Aplikacja z takim uprawnieniem może udostępniać i zapisywać dane kalendarza niezależnie od ich poufności."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="3191352452242394196">"Pozwala aplikacji odczytywać wszystkie zapisane na urządzeniu wydarzenia z kalendarza, również należące do znajomych i współpracowników. Może to umożliwić aplikacji przekazywanie lub zapisywanie danych z kalendarza, także tych poufnych."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Pozwala aplikacji  na odczytywanie wszystkich wydarzeń w kalendarzu zapisanych na telefonie, w tym pochodzących od znajomych i współpracowników. Aplikacja z takim uprawnieniem może udostępniać i zapisywać dane kalendarza niezależnie od ich poufności."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"dodawanie i modyfikowanie wydarzeń w kalendarzu oraz wysyłanie e-maili do gości bez wiedzy właściciela"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Pozwala aplikacji na dodawanie, usuwanie i zmienianie zdarzeń, które możesz modyfikować na swoim tablecie, w tym pochodzących od znajomych i współpracowników. Aplikacja z tym uprawnieniem może wysyłać wiadomości, które wyglądają jak pochodzące od właścicieli kalendarza, a także modyfikować zdarzenia bez wiedzy właścicieli."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="1273290605500902507">"Pozwala aplikacji dodawać, usuwać i zmieniać wydarzenia, które możesz modyfikować na telewizorze, w tym wydarzenia należące do znajomych lub współpracowników. Może to pozwolić aplikacji na wysyłanie wiadomości wyglądających jak utworzone przez właścicieli kalendarza lub modyfikować wydarzenia bez wiedzy ich właścicieli."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Pozwala aplikacji na dodawanie, usuwanie i zmienianie zdarzeń, które możesz modyfikować na swoim telefonie, w tym pochodzących od znajomych i współpracowników. Aplikacja z tym uprawnieniem może wysyłać wiadomości, które wyglądają jak pochodzące od właścicieli kalendarza, a także modyfikować zdarzenia bez wiedzy właścicieli."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"dostęp do dodatkowych poleceń dostawcy informacji o lokalizacji"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="6078307221056649927">"Pozwala aplikacji na dostęp do dodatkowych poleceń dostawcy informacji o lokalizacji. Aplikacje z tym uprawnieniem mogą wpływać na działanie GPS-u lub innych źródeł lokalizacji."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"dokładna lokalizacja (na podstawie sygnału GPS i sieci)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Zezwala aplikacji na określanie dokładnej lokalizacji dzięki sygnałowi GPS lub źródłom lokalizacji sieciowej, takim jak wieże sieci komórkowych i sieci Wi-Fi. Te usługi lokalizacyjne muszą być włączone i dostępne dla urządzenia, by aplikacja mogła z nich korzystać. Gdy to uprawnienie jest aktywne, aplikacje mogą określać Twoje położenie. Pamiętaj jednak, że telefon zużywa wtedy więcej energii."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"przybliżona lokalizacja (na podstawie sieci)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Zezwala aplikacji na określanie przybliżonej lokalizacji. Jest ona odczytywana z usług lokalizacyjnych wykorzystujących źródła lokalizacji sieciowej, takie jak wieże sieci komórkowych i sieci Wi-Fi. Te usługi lokalizacyjne muszą być włączone i dostępne dla urządzenia, by aplikacja mogła z nich korzystać. Gdy to uprawnienie jest aktywne, aplikacje mogą określać Twoje przybliżone położenie."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"zmienianie ustawień audio"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Pozwala aplikacji na modyfikowanie globalnych ustawień dźwięku, takich jak głośność oraz urządzenie wyjściowe."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"nagrywanie dźwięku"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Pozwala aplikacji na nagrywanie dźwięku przez mikrofon. Aplikacja z tym uprawnieniem może nagrywać dźwięk w dowolnym momencie bez Twojego potwierdzenia."</string>
    <string name="permlab_sim_communication" msgid="1180265879464893029">"komunikacja z kartą SIM"</string>
    <string name="permdesc_sim_communication" msgid="5725159654279639498">"Pozwala aplikacji na wysyłanie poleceń do karty SIM. To bardzo niebezpieczne."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"wykonywanie zdjęć i filmów wideo"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Pozwala aplikacji na robienie zdjęć i nagrywanie filmów przy użyciu aparatu. Aplikacja z tym uprawnieniem może użyć aparatu w dowolnym momencie bez Twojego potwierdzenia."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"sterowanie wibracjami"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Pozwala aplikacji na sterowanie wibracjami."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"kontrolowanie latarki"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Pozwala aplikacji na sterowanie latarką."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"bezpośrednie wybieranie numerów telefonów"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Pozwala aplikacji na dzwonienie pod numery telefonów bez Twojej wiedzy. Może to skutkować nieoczekiwanymi opłatami lub połączeniami. Aplikacja nie może dzwonić pod numery alarmowe. Złośliwe aplikacje mogą generować koszty, wykonując połączenia bez Twojego potwierdzenia."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"odczytywanie stanu i informacji o telefonie"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Pozwala aplikacji na dostęp do funkcji telefonicznych urządzenia. Aplikacja z tym uprawnieniem może odczytać numer telefonu i identyfikator urządzenia, sprawdzić, czy połączenie jest aktywne, oraz poznać numer, z którym jest nawiązane połączenie."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"zapobieganie przechodzeniu tabletu do trybu uśpienia"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2601193288949154131">"powstrzymywanie usypiania telewizora"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"zapobieganie przejściu telefonu w stan uśpienia"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Pozwala aplikacji na zapobieganie przechodzeniu tabletu do trybu uśpienia."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="3208534859208996974">"Pozwala aplikacji powstrzymać uśpienie telewizora."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Pozwala aplikacji na zapobieganie przechodzeniu telefonu w tryb uśpienia."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"przesyłanie w podczerwieni"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Zezwala aplikacji na używanie nadajnika podczerwieni w tablecie."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="3926790828514867101">"Pozwala aplikacji używać nadajnika podczerwieni telewizora."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Zezwala aplikacji na używanie nadajnika podczerwieni w telefonie."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"ustawianie tapety"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Pozwala aplikacji na ustawianie tapety systemu."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"dopasowywanie rozmiaru tapety"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Pozwala aplikacji na ustawianie wskazówek dotyczących rozmiaru tapety systemu."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"ustawianie strefy czasowej"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Pozwala aplikacji na zmianę ustawienia strefy czasowej w tablecie."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="888864653946175955">"Pozwala aplikacji zmieniać strefę czasową telewizora."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Pozwala aplikacji na zmianę ustawienia strefy czasowej w telefonie."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"znajdowanie kont na urządzeniu"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Pozwala aplikacji na uzyskanie listy kont zapisanych w tablecie. Może ona obejmować wszystkie konta utworzone przez zainstalowane aplikacje."</string>
    <string name="permdesc_getAccounts" product="tv" msgid="4190633395633907543">"Pozwala aplikacji odczytywać listę kont zapisanych na telewizorze, która może zawierać konta utworzone przez zainstalowane aplikacje."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Pozwala aplikacji na uzyskanie listy kont zapisanych w telefonie. Może ona obejmować wszystkie konta utworzone przez zainstalowane aplikacje."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"wyświetlanie połączeń sieciowych"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Pozwala aplikacji na dostęp do informacji o połączeniach sieciowych – np. o dostępnych i połączonych sieciach."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"pełny dostęp do sieci"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Pozwala aplikacji na tworzenie gniazd sieciowych i używanie niestandardowych protokołów sieciowych. Przeglądarka i inne aplikacje zapewniają metody wysyłania danych do internetu, więc w ich przypadku to uprawnienie nie jest potrzebne."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"zmienianie połączeń sieci"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Pozwala aplikacji na zmianę stanu łączności sieciowej."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"zmiana łączności powiązanej"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Pozwala aplikacji na zmianę stanu łączności sieciowej objętej tetheringiem."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"wyświetlanie połączeń Wi-Fi"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Pozwala aplikacji na dostęp do informacji o połączeniach Wi-Fi – np. na sprawdzenie, czy obsługa Wi-Fi jest włączona, oraz odczytanie nazw podłączonych urządzeń Wi-Fi."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"łączenie się i rozłączanie z siecią Wi‑Fi"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Pozwala aplikacji na nawiązywanie i kończenie połączeń z punktami dostępowymi Wi-Fi oraz na zmienianie konfiguracji sieci Wi-Fi w urządzeniu."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"zezwolenie na odbiór grupowych połączeń Wi-Fi"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Pozwala aplikacji na odbieranie pakietów wysyłanych przez sieć Wi-Fi do wszystkich urządzeń, a nie tylko do Twojego tabletu, przy użyciu adresów połączeń grupowych. Powoduje większe zapotrzebowanie na energię niż w trybie innym niż grupowy."</string>
    <string name="permdesc_changeWifiMulticastState" product="tv" msgid="9031975661145014160">"Pozwala aplikacji odbierać pakiety wysyłane do wszystkich urządzeń w sieci Wi-Fi (nie tylko do telewizora) przy użyciu adresów multicast. Zużycie energii w trybie multicast jest większe niż normalnie."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Pozwala aplikacji na odbieranie pakietów wysyłanych przez sieć Wi-Fi do wszystkich urządzeń, a nie tylko do Twojego telefonu, przy użyciu adresów połączeń grupowych. Powoduje większe zapotrzebowanie na energię niż w trybie innym niż grupowy."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"uzyskiwanie dostępu do ustawień Bluetooth"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Pozwala aplikacji na konfigurowanie lokalnego tabletu z funkcją Bluetooth oraz na wykrywanie urządzeń zdalnych i parowanie z nimi."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="3373125682645601429">"Pozwala aplikacji konfigurować Bluetooth w telewizorze oraz wykrywać inne urządzenia i parować go z nimi."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Pozwala aplikacji na konfigurowanie lokalnego telefonu z funkcją Bluetooth oraz na wykrywanie urządzeń zdalnych i parowanie z nimi."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"łączenie się i rozłączanie z siecią WiMAX"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Pozawala aplikacji określić, czy obsługa WiMAX jest włączona, oraz uzyskać informacje o wszystkich podłączonych sieciach WiMAX."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"zmienianie stanu WiMAX"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Pozwala aplikacji na nawiązywanie i kończenie połączeń z sieciami WiMAX w tablecie."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="6022307083934827718">"Pozwala aplikacji nawiązywać i kończyć połączenia telewizora z sieciami WiMAX."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Pozwala aplikacji na nawiązywanie i kończenie połączeń z sieciami WiMAX w telefonie."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"parowanie z urządzeniami Bluetooth"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Pozwala aplikacji na dostęp do konfiguracji Bluetooth na tablecie oraz na nawiązywanie i akceptowanie połączeń ze sparowanych urządzeń."</string>
    <string name="permdesc_bluetooth" product="tv" msgid="3974124940101104206">"Pozwala aplikacji odczytywać konfigurację Bluetooth w telewizorze oraz nawiązywać i akceptować połączenia ze sparowanymi urządzeniami."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Pozwala aplikacji na dostęp do konfiguracji Bluetooth na telefonie oraz na nawiązywanie i akceptowanie połączeń ze sparowanych urządzeń."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"kontrolowanie łączności Near Field Communication"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Pozwala aplikacji na komunikowanie się z tagami, kartami i czytnikami NFC (Near Field Communication)."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"wyłączanie blokady ekranu"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Pozwala aplikacji na wyłączenie blokady klawiatury i wszystkich związanych z tym haseł zabezpieczających. Na przykład telefon wyłącza blokadę klawiatury, gdy odbiera połączenie przychodzące, a następnie włącza ją ponownie po zakończeniu połączenia."</string>
    <string name="permlab_manageFingerprint" msgid="5640858826254575638">"zarządzanie czytnikiem linii papilarnych"</string>
    <string name="permdesc_manageFingerprint" msgid="178208705828055464">"Zezwala aplikacji aktywować metody dodawania i usuwania szablonów odcisków palców."</string>
    <string name="permlab_useFingerprint" msgid="3150478619915124905">"używanie czytnika linii papilarnych"</string>
    <string name="permdesc_useFingerprint" msgid="9165097460730684114">"Zezwala aplikacji na używanie czytnika linii papilarnych na potrzeby autoryzacji"</string>
    <string name="fingerprint_acquired_partial" msgid="735082772341716043">"Odcisk palca został odczytany tylko częściowo. Spróbuj ponownie."</string>
    <string name="fingerprint_acquired_insufficient" msgid="4596546021310923214">"Nie udało się przetworzyć linii papilarnych. Spróbuj ponownie."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="1087209702421076105">"Czytnik linii papilarnych jest zabrudzony. Wyczyść go i spróbuj ponownie."</string>
    <string name="fingerprint_acquired_too_fast" msgid="6470642383109155969">"Palec został uniesiony zbyt szybko. Spróbuj ponownie."</string>
    <string name="fingerprint_acquired_too_slow" msgid="59250885689661653">"Palec został przesunięty zbyt wolno. Spróbuj ponownie."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_error_hw_not_available" msgid="7955921658939936596">"Czytnik linii papilarnych nie jest dostępny."</string>
    <string name="fingerprint_error_no_space" msgid="1055819001126053318">"Nie można zapisać odcisku palca. Usuń istniejący odcisk palca."</string>
    <string name="fingerprint_error_timeout" msgid="3927186043737732875">"Osiągnięto limit czasu odczytu linii papilarnych. Spróbuj ponownie."</string>
    <string name="fingerprint_error_canceled" msgid="4402024612660774395">"Odczyt odcisku palca został anulowany."</string>
    <string name="fingerprint_error_lockout" msgid="5536934748136933450">"Zbyt wiele prób. Spróbuj ponownie później."</string>
    <string name="fingerprint_error_unable_to_process" msgid="6107816084103552441">"Spróbuj ponownie."</string>
    <string name="fingerprint_name_template" msgid="5870957565512716938">"Palec <xliff:g id="FINGERID">%d</xliff:g>"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"czytanie ustawień synchronizacji"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Zezwala aplikacji na odczyt ustawień synchronizacji konta. Pozwala to na przykład określić, czy aplikacja Ludzie jest zsynchronizowana z kontem."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"włączanie i wyłączanie synchronizacji"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Pozwala aplikacji na modyfikowanie ustawień synchronizacji z kontem. Tego uprawnienia można użyć np. do włączenia synchronizacji z kontem aplikacji Ludzie."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"czytanie statystyk dotyczących synchronizowania"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Pozwala aplikacji na czytanie statystyk synchronizacji konta, w tym historii zdarzeń synchronizacji oraz ilości zsynchronizowanych danych."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"odczytywanie terminów dodanych do słownika"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Pozwala aplikacji na odczytywanie wszelkich słów, nazw i wyrażeń zapisanych w słowniku użytkownika."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"dodawanie wyrazów do słownika zdefiniowanego przez użytkownika"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Pozwala aplikacji na zapisywanie nowych słów do słownika użytkownika."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="367275095159405468">"odczytywanie zawartości pamięci USB"</string>
    <string name="permlab_sdcardRead" product="default" msgid="2188156462934977940">"odczytywanie zawartości karty SD"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3446988712598386079">"Pozwala aplikacji na odczyt Twojej pamięci USB."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="2607362473654975411">"Pozwala aplikacji na odczyt Twojej karty SD."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"modyfikowanie i usuwanie zawartości pamięci USB"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"modyfikowanie i usuwanie zawartości karty SD"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Pozwala aplikacji na zapis w pamięci USB."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Pozwala aplikacji na zapis na karcie SD."</string>
    <string name="permlab_use_sip" msgid="2052499390128979920">"wykonywanie/odbieranie połączeń SIP"</string>
    <string name="permdesc_use_sip" msgid="2297804849860225257">"Pozwala aplikacji na wykonywanie i odbieranie połączeń SIP."</string>
    <string name="permlab_register_sim_subscription" msgid="3166535485877549177">"rejestrowanie nowych połączeń telekomunikacyjnych SIM"</string>
    <string name="permdesc_register_sim_subscription" msgid="2138909035926222911">"Zezwala aplikacji na rejestrowanie nowych połączeń telekomunikacyjnych SIM."</string>
    <string name="permlab_register_call_provider" msgid="108102120289029841">"rejestrowanie nowych połączeń telekomunikacyjnych"</string>
    <string name="permdesc_register_call_provider" msgid="7034310263521081388">"Zezwala aplikacji na rejestrowanie nowych połączeń telekomunikacyjnych."</string>
    <string name="permlab_connection_manager" msgid="1116193254522105375">"zarządzanie połączeniami telekomunikacyjnymi"</string>
    <string name="permdesc_connection_manager" msgid="5925480810356483565">"Zezwala aplikacji na zarządzanie połączeniami telekomunikacyjnymi."</string>
    <string name="permlab_bind_incall_service" msgid="6773648341975287125">"interakcje z ekranem połączenia"</string>
    <string name="permdesc_bind_incall_service" msgid="8343471381323215005">"Zezwala aplikacji na kontrolowanie, kiedy i w jaki sposób użytkownik widzi ekran połączenia."</string>
    <string name="permlab_bind_connection_service" msgid="3557341439297014940">"korzystanie z usług telefonii"</string>
    <string name="permdesc_bind_connection_service" msgid="4008754499822478114">"Pozwala aplikacji na korzystanie z usług telefonii oraz wykonywanie i odbieranie połączeń."</string>
    <string name="permlab_control_incall_experience" msgid="9061024437607777619">"udostępnianie użytkownikowi funkcji połączenia"</string>
    <string name="permdesc_control_incall_experience" msgid="915159066039828124">"Zezwala aplikacji na udostępnianie użytkownikowi funkcji połączenia."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"odczyt historii wykorzystania sieci"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Pozwala aplikacji na odczyt historii wykorzystania określonych sieci przez poszczególne aplikacje."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"zarządzanie zasadami dotyczącymi sieci"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Pozwala aplikacji na zarządzanie zasadami dotyczącymi sieci i definiowanie reguł aplikacji."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"modyfikowanie sposobu naliczania użycia sieci"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Pozwala aplikacji na zmienianie sposobu rozliczania wykorzystania sieci przez aplikacje. Nieprzeznaczone dla zwykłych aplikacji."</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"dostęp do powiadomień"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Umożliwia aplikacji pobieranie, sprawdzanie i usuwanie powiadomień, także tych, które pochodzą z innych aplikacji."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"utwórz połączenie z usługą odbiornika powiadomień"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Zezwala na tworzenie powiązania z interfejsem najwyższego poziomu usługi odbiornika powiadomień. Nie powinno być nigdy potrzebne dla zwykłych aplikacji."</string>
    <string name="permlab_bindConditionProviderService" msgid="1180107672332704641">"powiąż z usługą dostawcy warunków"</string>
    <string name="permdesc_bindConditionProviderService" msgid="1680513931165058425">"Zezwala na tworzenie powiązania z interfejsem najwyższego poziomu usługi dostawcy warunków. Nieprzeznaczone dla zwykłych aplikacji."</string>
    <string name="permlab_bindDreamService" msgid="4153646965978563462">"powiąż z usługą wygaszacza ekranu"</string>
    <string name="permdesc_bindDreamService" msgid="7325825272223347863">"Zezwala na tworzenie powiązania z interfejsem najwyższego poziomu usługi wygaszacza ekranu. Nie powinno być nigdy potrzebne dla zwykłych aplikacji."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"wywoływanie aplikacji konfiguracyjnej udostępnionej przez operatora"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Zezwala na wywoływanie aplikacji konfiguracyjnej udostępnionej przez operatora. Nieprzeznaczone dla zwykłych aplikacji."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"śledź stan sieci"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Pozwala aplikacji śledzić stan sieci. Nieprzeznaczone dla zwykłych aplikacji."</string>
    <string name="permlab_setInputCalibration" msgid="4902620118878467615">"zmiana kalibracji urządzenia wejściwego"</string>
    <string name="permdesc_setInputCalibration" msgid="4527511047549456929">"Zezwala aplikacji na modyfikowanie parametrów kalibracji ekranu dotykowego. Nieprzeznaczone dla zwykłych aplikacji."</string>
    <string name="permlab_accessDrmCertificates" msgid="7436886640723203615">"dostęp do certyfikatów DRM"</string>
    <string name="permdesc_accessDrmCertificates" msgid="8073288354426159089">"Zezwala aplikacji na dodanie i używanie certyfikatów DRM. Nieprzeznaczone dla zwykłych aplikacji."</string>
    <string name="permlab_handoverStatus" msgid="1159132046126626731">"Uzyskiwanie informacji o stanie transmisji Android Beam"</string>
    <string name="permdesc_handoverStatus" msgid="4788144087245714948">"Zezwala tej aplikacji na otrzymywanie informacji o aktualnych transmisjach Android Beam"</string>
    <string name="permlab_removeDrmCertificates" msgid="7044888287209892751">"usuwanie certyfikatów DRM"</string>
    <string name="permdesc_removeDrmCertificates" msgid="7272999075113400993">"Zezwala aplikacji na usuwanie certyfikatów DRM. Nie powinno być nigdy potrzebne w zwykłych aplikacjach."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="1490229371796969158">"powiąż z usługą przesyłania wiadomości przez operatora"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="2762882888502113944">"Zezwala posiadaczowi na tworzenie powiązania z interfejsem najwyższego poziomu w usłudze przesyłania wiadomości przez operatora. Nie powinno być nigdy potrzebne dla zwykłych aplikacji."</string>
    <string name="permlab_bindCarrierServices" msgid="3233108656245526783">"powiązanie z usługami operatora"</string>
    <string name="permdesc_bindCarrierServices" msgid="1391552602551084192">"Umożliwia właścicielowi powiązanie z usługami operatora. Nie powinno być nigdy potrzebne w normalnych aplikacjach."</string>
    <string name="permlab_access_notification_policy" msgid="4247510821662059671">"dostęp do trybu Nie przeszkadzać"</string>
    <string name="permdesc_access_notification_policy" msgid="3296832375218749580">"Pozwala aplikacji na odczyt i zmianę konfiguracji trybu Nie przeszkadzać."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Określ reguły hasła"</string>
    <string name="policydesc_limitPassword" msgid="2502021457917874968">"Kontrolowanie długości haseł blokady ekranu i kodów PIN oraz dozwolonych w nich znaków."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Monitoruj próby odblokowania ekranu"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Przy odblokowywaniu ekranu monitoruj, ile razy wpisano nieprawidłowe hasło i blokuj tablet lub usuń z niego wszystkie dane, jeśli nieprawidłowe hasło podano zbyt wiele razy."</string>
    <string name="policydesc_watchLogin" product="TV" msgid="2707817988309890256">"Monitorowanie, ile razy wpisano niepoprawne hasło podczas odblokowywania ekranu, oraz blokowanie telewizora albo kasowanie na nim wszystkich danych, gdy zbyt wiele razy wpisano niepoprawne hasło."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Przy odblokowywaniu ekranu monitoruje, ile razy wpisano nieprawidłowe hasło, i blokuje telefon lub usuwa z niego wszystkie dane, jeśli nieprawidłowe hasło podano zbyt wiele razy"</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet" msgid="4280246270601044505">"Monitorowanie, ile razy wpisano błędne hasło podczas odblokowywania ekranu, oraz blokowanie tabletu albo kasowanie wszystkich danych tego użytkownika, gdy zbyt wiele razy wpisano błędne hasło."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="TV" msgid="3484832653564483250">"Monitorowanie, ile razy wpisano błędne hasło podczas odblokowywania ekranu, oraz blokowanie telewizora albo kasowanie wszystkich danych tego użytkownika, gdy zbyt wiele razy wpisano błędne hasło."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="2185480427217127147">"Monitorowanie, ile razy wpisano błędne hasło podczas odblokowywania ekranu, oraz blokowanie telefonu albo kasowanie wszystkich danych tego użytkownika, gdy zbyt wiele razy wpisano błędne hasło."</string>
    <string name="policylab_resetPassword" msgid="4934707632423915395">"Zmiana blokady ekranu"</string>
    <string name="policydesc_resetPassword" msgid="1278323891710619128">"Zmiana blokady ekranu"</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Blokowanie ekranu"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Kontrolowanie sposobu i warunków blokowania ekranu"</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Usuwanie wszystkich danych"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Wymazywanie danych z tabletu bez ostrzeżenia przez przywrócenie danych fabrycznych"</string>
    <string name="policydesc_wipeData" product="tv" msgid="5816221315214527028">"Skasowanie danych w telewizorze bez ostrzeżenia przez przywrócenie danych fabrycznych."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Wymazywanie danych z telefonu bez ostrzeżenia przez przywrócenie danych fabrycznych"</string>
    <string name="policylab_wipeData_secondaryUser" msgid="8362863289455531813">"Kasuj dane użytkownika"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="6336255514635308054">"Kasowanie danych tego użytkownika na tym tablecie bez ostrzeżenia."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="2086473496848351810">"Kasowanie danych tego użytkownika na tym telewizorze bez ostrzeżenia."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="6787904546711590238">"Kasowanie danych tego użytkownika na tym telefonie bez ostrzeżenia."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Ustaw globalny serwer proxy urządzenia"</string>
    <string name="policydesc_setGlobalProxy" msgid="8459859731153370499">"Ustawianie globalnego serwera proxy urządzenia do użycia przy włączonych zasadach. Tylko właściciel urządzenia może ustawić globalny serwer proxy."</string>
    <string name="policylab_expirePassword" msgid="5610055012328825874">"Ustaw czas ważności hasła blokady ekranu"</string>
    <string name="policydesc_expirePassword" msgid="5367525762204416046">"Zmiana częstotliwości, z jaką należy zmieniać hasło blokady ekranu, kod PIN lub wzór."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Ustaw szyfrowanie pamięci"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Wymaganie szyfrowania przechowywanych danych aplikacji"</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Wyłącz aparaty"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Zapobieganie używaniu wszystkich aparatów w urządzeniu"</string>
    <string name="policylab_disableKeyguardFeatures" msgid="8552277871075367771">"Wył. niektórych funkcji bl. ekr."</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="2044755691354158439">"Zapobieganie użyciu niektórych funkcji blokady ekranu."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Dom"</item>
    <item msgid="869923650527136615">"Komórka"</item>
    <item msgid="7897544654242874543">"Praca"</item>
    <item msgid="1103601433382158155">"Faks w pracy"</item>
    <item msgid="1735177144948329370">"Faks domowy"</item>
    <item msgid="603878674477207394">"Pager"</item>
    <item msgid="1650824275177931637">"Inny"</item>
    <item msgid="9192514806975898961">"Niestandardowy"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Dom"</item>
    <item msgid="7084237356602625604">"Praca"</item>
    <item msgid="1112044410659011023">"Inne"</item>
    <item msgid="2374913952870110618">"Niestandardowy"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Dom"</item>
    <item msgid="5629153956045109251">"Praca"</item>
    <item msgid="4966604264500343469">"Inny"</item>
    <item msgid="4932682847595299369">"Niestandardowy"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Dom"</item>
    <item msgid="1359644565647383708">"Praca"</item>
    <item msgid="7868549401053615677">"Inne"</item>
    <item msgid="3145118944639869809">"Niestandardowy"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Praca"</item>
    <item msgid="4378074129049520373">"Inne"</item>
    <item msgid="3455047468583965104">"Niestandardowy"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="8595261363518459565">"AIM"</item>
    <item msgid="7390473628275490700">"Windows Live"</item>
    <item msgid="7882877134931458217">"Yahoo"</item>
    <item msgid="5035376313200585242">"Skype"</item>
    <item msgid="7532363178459444943">"QQ"</item>
    <item msgid="3713441034299660749">"Google Talk"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Niestandardowy"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Domowy"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Komórka"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Służbowy"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Faks służbowy"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Faks domowy"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pager"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Inny"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Oddzwanianie"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Samochód"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Firmowy główny"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Główny"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Inny faks"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radio"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Teleks"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Służbowa komórka"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Pager służbowy"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Asystent"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"Wiadomość MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Niestandardowe"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Urodziny"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Rocznica"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Inne"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Niestandardowy"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Domowy"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Służbowy"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Inny"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Komórka"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Niestandardowy"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Domowy"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Służbowy"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Inny"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Niestandardowy"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Domowy"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Służbowy"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Inny"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Niestandardowy"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="493902321140277304">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Służbowy"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Inny"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Niestandardowy"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Niestandardowa"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Asystent"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Brat"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Dziecko"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Partner życiowy"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Ojciec"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Znajomy"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Menedżer"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Matka"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Rodzic"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Z polecenia"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Krewny"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Siostra"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Współmałżonek"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Niestandardowy"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Domowy"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Służbowy"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Inny"</string>
    <string name="quick_contacts_not_available" msgid="746098007828579688">"Brak aplikacji do wyświetlenia tego kontaktu."</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Wpisz kod PIN."</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Wpisz kod PUK i nowy kod PIN."</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"Kod PUK"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Nowy PIN"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Dotknij, aby wpisać hasło."</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Wpisz hasło, aby odblokować."</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Wpisz kod PIN, aby odblokować."</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Błędny kod PIN"</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Aby odblokować, naciśnij Menu, a następnie 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Numer alarmowy"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Brak usługi"</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Ekran zablokowany."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Naciśnij Menu, aby odblokować lub wykonać połączenie alarmowe."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Naciśnij Menu, aby odblokować."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Narysuj wzór, aby odblokować"</string>
    <string name="lockscreen_emergency_call" msgid="5298642613417801888">"Alarmowe"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Powrót do połączenia"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Poprawnie!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Spróbuj ponownie."</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Spróbuj ponownie."</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Przekroczono maksymalną liczbę prób rozpoznania twarzy."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Brak karty SIM"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"Brak karty SIM w tablecie."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="1943633865476989599">"Brak karty SIM w telewizorze."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"Brak karty SIM w telefonie."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Włóż kartę SIM."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"Brak karty SIM lub nie można jej odczytać. Włóż kartę SIM."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Karta SIM bezużyteczna."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Karta SIM jest trwale wyłączona.\n Skontaktuj się z dostawcą usług bezprzewodowych, aby uzyskać inną kartę SIM."</string>
    <string name="lockscreen_transport_prev_description" msgid="6300840251218161534">"Poprzedni utwór"</string>
    <string name="lockscreen_transport_next_description" msgid="573285210424377338">"Następny utwór"</string>
    <string name="lockscreen_transport_pause_description" msgid="3980308465056173363">"Wstrzymaj"</string>
    <string name="lockscreen_transport_play_description" msgid="1901258823643886401">"Odtwórz"</string>
    <string name="lockscreen_transport_stop_description" msgid="5907083260651210034">"Zatrzymaj"</string>
    <string name="lockscreen_transport_rew_description" msgid="6944412838651990410">"Przewiń do tyłu"</string>
    <string name="lockscreen_transport_ffw_description" msgid="42987149870928985">"Przewiń do przodu"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Tylko połączenia alarmowe"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Sieć zablokowana"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"Karta SIM jest zablokowana kodem PUK."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Zapoznaj się z instrukcją obsługi lub skontaktuj się z działem obsługi klienta."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"Karta SIM jest zablokowana."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Odblokowywanie karty SIM..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"Wzór odblokowania został nieprawidłowo narysowany <xliff:g id="NUMBER_0">%d</xliff:g> razy. \n\nSpróbuj ponownie za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"Po raz <xliff:g id="NUMBER_0">%d</xliff:g> zostało wpisane nieprawidłowe hasło. \n\nSpróbuj ponownie za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"Po raz <xliff:g id="NUMBER_0">%d</xliff:g> został wpisany nieprawidłowy PIN. \n\nSpróbuj ponownie za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"Wzór odblokowania został <xliff:g id="NUMBER_0">%d</xliff:g> razy narysowany nieprawidłowo. Po <xliff:g id="NUMBER_1">%d</xliff:g> kolejnych próbach zakończonych niepowodzeniem konieczne będzie odblokowanie tabletu przy użyciu danych logowania na konto Google.\n\n Spróbuj ponownie za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="5316664559603394684">"Wzór odblokowania narysowałeś niepoprawnie <xliff:g id="NUMBER_0">%d</xliff:g> razy. Po jeszcze <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach trzeba będzie odblokować telewizor przy użyciu danych logowania konta Google.\n\n Spróbuj ponownie za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"Wzór odblokowania został <xliff:g id="NUMBER_0">%d</xliff:g> razy narysowany nieprawidłowo. Po <xliff:g id="NUMBER_1">%d</xliff:g> kolejnych próbach zakończonych niepowodzeniem konieczne będzie odblokowanie telefonu przy użyciu danych logowania na konto Google.\n\n Spróbuj ponownie za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"Próbowano <xliff:g id="NUMBER_0">%d</xliff:g> razy nieprawidłowo odblokować tablet. Po kolejnych <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach tablet zostanie zresetowany do ustawień fabrycznych, a wszystkie dane użytkownika zostaną utracone."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv" msgid="950408382418270260">"Podałeś nieprawidłowe dane odblokowania telewizora <xliff:g id="NUMBER_0">%d</xliff:g> razy. Po jeszcze <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach telewizor zostanie zresetowany do stanu fabrycznego, a wszystkie dane użytkownika zostaną skasowane."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"Próbowano <xliff:g id="NUMBER_0">%d</xliff:g> razy nieprawidłowo odblokować telefon. Po kolejnych <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach telefon zostanie zresetowany do ustawień fabrycznych, a wszystkie dane użytkownika zostaną utracone."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"Próbowano <xliff:g id="NUMBER">%d</xliff:g> razy nieprawidłowo odblokować tablet. Tablet zostanie teraz zresetowany do ustawień fabrycznych."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tv" msgid="3195755534096192191">"Podałeś nieprawidłowe dane odblokowania telewizora <xliff:g id="NUMBER">%d</xliff:g> razy. Zostanie on teraz zresetowany do stanu fabrycznego."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"Próbowano <xliff:g id="NUMBER">%d</xliff:g> razy nieprawidłowo odblokować telefon. Telefon zostanie teraz zresetowany do ustawień fabrycznych."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Spróbuj ponownie za <xliff:g id="NUMBER">%d</xliff:g> sek."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Zapomniałeś wzoru?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Odblokowanie konta"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Zbyt wiele prób narysowania wzoru"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Aby odblokować, zaloguj się za pomocą konta Google."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Nazwa użytkownika (e-mail)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Hasło"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Zaloguj się"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Błędna nazwa użytkownika lub hasło."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Nie pamiętasz nazwy użytkownika lub hasła?\nOdwiedź stronę "<b>"google.com/accounts/recovery"</b></string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Sprawdzanie…"</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Odblokuj"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Włącz dźwięk"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Wyłącz dźwięk"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Wzór rozpoczęty"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Wzór wyczyszczony"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Dodano komórkę."</string>
    <!-- no translation found for lockscreen_access_pattern_cell_added_verbose (7264580781744026939) -->
    <skip />
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Wzór ukończony"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. Widżet %2$d z %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Dodaj widżet."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Puste"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Rozwinięto obszar odblokowania."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Zwinięto obszar odblokowania."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Widżet <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Wybór użytkownika"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Stan"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Aparat"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Elementy sterujące multimediów"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Rozpoczęto zmienianie kolejności widżetów."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Zakończono zmienianie kolejności widżetów."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Usunięto widżet <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Rozwiń obszar odblokowania."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Odblokowanie przesunięciem."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Odblokowanie wzorem."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Rozpoznanie twarzy"</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Odblokowanie kodem PIN."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Odblokowanie hasłem."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Obszar wzoru."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Obszar przesuwania."</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"ALT"</string>
    <string name="granularity_label_character" msgid="7336470535385009523">"znak"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"słowo"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"link"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"wiersz"</string>
    <string name="hour_ampm" msgid="4584338083529355982">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%P</xliff:g>"</string>
    <string name="hour_cap_ampm" msgid="2083465992940444366">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%p</xliff:g>"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Nieudany test fabryczny"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Czynność FACTORY_TEST jest obsługiwana tylko dla pakietów zainstalowanych w katalogu /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Nie znaleziono żadnego pakietu, który zapewnia działanie FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Uruchom ponownie"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Komunikat ze strony pod adresem „<xliff:g id="TITLE">%s</xliff:g>”:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Potwierdź przejście"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Opuść tę stronę"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Pozostań na tej stronie"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nCzy na pewno chcesz opuścić tę stronę?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Potwierdź"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Wskazówka: dotknij dwukrotnie, aby powiększyć lub pomniejszyć."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Autouzupełnianie"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Ustaw autouzupełnianie"</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"Województwo"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Kod pocztowy"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Stan"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Kod pocztowy"</string>
    <string name="autofill_county" msgid="237073771020362891">"Powiat"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Wyspa"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Dystrykt"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Departament"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektura"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Gmina"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Obszar"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"odczytywanie zakładek internetowych i historii"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Pozwala aplikacji na odczyt wszystkich URL-i odwiedzonych przez przeglądarkę oraz wszystkich zakładek w przeglądarce. Uwaga: to uprawnienie może nie być egzekwowane przez przeglądarki innych firm i aplikacje z możliwością przeglądania internetu."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"zapisywanie zakładek internetowych i historii"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Pozwala aplikacji na modyfikowanie historii i zakładek przeglądarki zapisanych na tablecie. Aplikacja będzie mogła usunąć lub zmodyfikować dane przeglądarki. Uwaga: to uprawnienie może nie być egzekwowane przez przeglądarki innych firm oraz inne aplikacje z możliwością przeglądania internetu."</string>
    <string name="permdesc_writeHistoryBookmarks" product="tv" msgid="7007393823197766548">"Pozwala aplikacji modyfikować historię i zakładki przeglądarki zapisane na telewizorze. Może to pozwolić aplikacji na usunięcie lub zmodyfikowanie danych przeglądarki. Uwaga: tego uprawnienia nie mogą wymusić przeglądarki innych producentów ani inne aplikacje z funkcjami przeglądania stron internetowych."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Pozwala aplikacji na modyfikowanie historii i zakładek przeglądarki zapisanych na telefonie. Aplikacja będzie mogła usunąć lub zmodyfikować dane przeglądarki. Uwaga: to uprawnienie może nie być egzekwowane przez przeglądarki innych firm oraz inne aplikacje z możliwością przeglądania internetu."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"ustawianie alarmu"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Pozwala aplikacji na ustawienie alarmu w zainstalowanej aplikacji budzika. Funkcja ta może nie być zaimplementowana w niektórych aplikacjach tego typu."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"dodawanie poczty głosowej"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Pozwala aplikacji na dodawanie wiadomości do skrzynki odbiorczej poczty głosowej."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"modyfikowanie pozwoleń przeglądarki dotyczących lokalizacji geograficznej"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Pozwala aplikacji na modyfikowanie uprawnień przeglądarki dotyczących lokalizacji geograficznej. Złośliwe aplikacje mogą używać tej opcji do wysyłania informacji o lokalizacji do dowolnych witryn."</string>
    <string name="save_password_message" msgid="767344687139195790">"Czy chcesz, aby zapamiętać to hasło w przeglądarce?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Nie teraz"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Zapamiętaj"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Nigdy"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Nie masz pozwolenia na otwarcie tej strony."</string>
    <string name="text_copied" msgid="4985729524670131385">"Tekst został skopiowany do schowka."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Więcej"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"spacja"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"enter"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"usuń"</string>
    <string name="search_go" msgid="8298016669822141719">"Szukaj"</string>
    <string name="search_hint" msgid="1733947260773056054">"Szukaj…"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Szukaj"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Wyszukiwane hasło"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Wyczyść zapytanie"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Wyślij zapytanie"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Wyszukiwanie głosowe"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Włączyć Czytanie dotykiem?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> chce włączyć Czytanie dotykiem. Gdy ta funkcja jest włączona, słyszysz i widzisz opisy elementów, które są pod Twoim palcem, oraz możesz obsługiwać tablet gestami."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> chce włączyć Czytanie dotykiem. Gdy ta funkcja jest włączona, słyszysz i widzisz opisy elementów, które są pod Twoim palcem, oraz możesz obsługiwać telefon gestami."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"1 miesiąc temu"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Ponad 1 miesiąc temu"</string>
    <plurals name="last_num_days" formatted="false" msgid="5104533550723932025">
      <item quantity="few">Ostatnie <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
      <item quantity="many">Ostatnich <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
      <item quantity="other">Ostatnie <xliff:g id="COUNT_1">%d</xliff:g> dnia</item>
      <item quantity="one">Ostatni <xliff:g id="COUNT_0">%d</xliff:g> dzień</item>
    </plurals>
    <string name="last_month" msgid="3959346739979055432">"Ostatni miesiąc"</string>
    <string name="older" msgid="5211975022815554840">"Starsze"</string>
    <string name="preposition_for_date" msgid="9093949757757445117">"w dniu <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"o godzinie <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"w <xliff:g id="YEAR">%s</xliff:g> r."</string>
    <string name="day" msgid="8144195776058119424">"dzień"</string>
    <string name="days" msgid="4774547661021344602">"dni"</string>
    <string name="hour" msgid="2126771916426189481">"godzina"</string>
    <string name="hours" msgid="894424005266852993">"godzin"</string>
    <string name="minute" msgid="9148878657703769868">"min"</string>
    <string name="minutes" msgid="5646001005827034509">"minut"</string>
    <string name="second" msgid="3184235808021478">"s"</string>
    <string name="seconds" msgid="3161515347216589235">"S"</string>
    <string name="week" msgid="5617961537173061583">"tydzień"</string>
    <string name="weeks" msgid="6509623834583944518">"tygodni"</string>
    <string name="year" msgid="4001118221013892076">"rok"</string>
    <string name="years" msgid="6881577717993213522">"lat"</string>
    <plurals name="duration_seconds" formatted="false" msgid="4527986939729687805">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> sekund</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
      <item quantity="one">1 sekunda</item>
    </plurals>
    <plurals name="duration_minutes" formatted="false" msgid="643786953939956125">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minuty</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> minut</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuty</item>
      <item quantity="one">1 minuta</item>
    </plurals>
    <plurals name="duration_hours" formatted="false" msgid="6826233369186668274">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> godziny</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> godzin</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> godziny</item>
      <item quantity="one">1 godzina</item>
    </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Problem z filmem"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Ten film nie nadaje się do strumieniowego przesyłania do tego urządzenia."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Nie można odtworzyć tego filmu."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"OK"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"południe"</string>
    <string name="Noon" msgid="3342127745230013127">"Południe"</string>
    <string name="midnight" msgid="7166259508850457595">"północ"</string>
    <string name="Midnight" msgid="5630806906897892201">"Północ"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Zaznacz wszystko"</string>
    <string name="cut" msgid="3092569408438626261">"Wytnij"</string>
    <string name="copy" msgid="2681946229533511987">"Kopiuj"</string>
    <string name="paste" msgid="5629880836805036433">"Wklej"</string>
    <string name="replace" msgid="5781686059063148930">"Zastąp"</string>
    <string name="delete" msgid="6098684844021697789">"Usuń"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Kopiuj adres URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Zaznacz tekst"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Zaznaczanie tekstu"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Dodaj do słownika"</string>
    <string name="deleteText" msgid="6979668428458199034">"Usuń"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Sposób wprowadzania tekstu"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Działania na tekście"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Kończy się miejsce"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Niektóre funkcje systemu mogą nie działać"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="6935190099204693424">"Za mało pamięci w systemie. Upewnij się, że masz 250 MB wolnego miejsca i uruchom urządzenie ponownie."</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"Aplikacja <xliff:g id="APP_NAME">%1$s</xliff:g> jest uruchomiona"</string>
    <string name="app_running_notification_text" msgid="4653586947747330058">"Kliknij, aby uzyskać więcej informacji lub zatrzymać aplikację."</string>
    <string name="ok" msgid="5970060430562524910">"OK"</string>
    <string name="cancel" msgid="6442560571259935130">"Anuluj"</string>
    <string name="yes" msgid="5362982303337969312">"OK"</string>
    <string name="no" msgid="5141531044935541497">"Anuluj"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Uwaga"</string>
    <string name="loading" msgid="7933681260296021180">"Wczytywanie…"</string>
    <string name="capital_on" msgid="1544682755514494298">"Wł"</string>
    <string name="capital_off" msgid="6815870386972805832">"Wył"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Wykonaj czynność przez..."</string>
    <string name="whichApplicationNamed" msgid="8260158865936942783">"Wykonaj czynność w aplikacji %1$s"</string>
    <string name="whichViewApplication" msgid="3272778576700572102">"Otwórz w aplikacji"</string>
    <string name="whichViewApplicationNamed" msgid="2286418824011249620">"Otwórz w aplikacji %1$s"</string>
    <string name="whichEditApplication" msgid="144727838241402655">"Edytuj w aplikacji"</string>
    <string name="whichEditApplicationNamed" msgid="1775815530156447790">"Edytuj w aplikacji %1$s"</string>
    <string name="whichSendApplication" msgid="6902512414057341668">"Udostępnij przez:"</string>
    <string name="whichSendApplicationNamed" msgid="2799370240005424391">"Udostępnij przez %1$s"</string>
    <string name="whichHomeApplication" msgid="4307587691506919691">"Wybierz aplikację ekranu głównego"</string>
    <string name="whichHomeApplicationNamed" msgid="4493438593214760979">"Użyj %1$s jako ekranu głównego"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Domyślne dla tej czynności"</string>
    <string name="use_a_different_app" msgid="8134926230585710243">"Użyj innej aplikacji"</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Wyczyść wartości domyślne w: Ustawienia systemu &gt; Aplikacje &gt; Pobrane."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Wybierz czynność"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Wybierz aplikację dla urządzenia USB"</string>
    <string name="noApplications" msgid="2991814273936504689">"Żadna z aplikacji nie może wykonać tej czynności."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Niestety, aplikacja <xliff:g id="APPLICATION">%1$s</xliff:g> została zatrzymana."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Niestety, proces <xliff:g id="PROCESS">%1$s</xliff:g> został zatrzymany."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"Aplikacja <xliff:g id="APPLICATION">%2$s</xliff:g> nie reaguje.\n\nCzy chcesz ją zamknąć?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Działanie <xliff:g id="ACTIVITY">%1$s</xliff:g> nie odpowiada.\n\nCzy chcesz je zakończyć?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"Aplikacja <xliff:g id="APPLICATION">%1$s</xliff:g> nie reaguje. Czy chcesz ją zamknąć?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> nie odpowiada.\n\nCzy chcesz go zakończyć?"</string>
    <string name="force_close" msgid="8346072094521265605">"OK"</string>
    <string name="report" msgid="4060218260984795706">"Zgłoś"</string>
    <string name="wait" msgid="7147118217226317732">"Czekaj"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Strona nie odpowiada na żądania.\n\nZamknąć ją?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Aplikacja przekierowana"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"Aplikacja <xliff:g id="APP_NAME">%1$s</xliff:g> jest uruchomiona."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"Aplikacja <xliff:g id="APP_NAME">%1$s</xliff:g> została pierwotnie uruchomiona."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Skala"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Zawsze pokazuj"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Włącz ponownie, wybierając Ustawienia systemowe &gt; Aplikacje &gt; Pobrane."</string>
    <string name="smv_application" msgid="3307209192155442829">"Aplikacja <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) naruszyła wymuszone przez siebie zasady StrictMode."</string>
    <string name="smv_process" msgid="5120397012047462446">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> naruszył wymuszone przez siebie zasady StrictMode."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Android jest uaktualniany..."</string>
    <string name="android_start_title" msgid="8418054686415318207">"Android się uruchamia…"</string>
    <string name="android_upgrading_fstrim" msgid="8036718871534640010">"Optymalizacja pamięci."</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"Optymalizowanie aplikacji <xliff:g id="NUMBER_0">%1$d</xliff:g> z <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_preparing_apk" msgid="8162599310274079154">"Przygotowuję aplikację <xliff:g id="APPNAME">%1$s</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Uruchamianie aplikacji."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Kończenie uruchamiania."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"Działa <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Dotknij, aby przejść do aplikacji."</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Czy przełączyć aplikacje?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Działa już inna aplikacja, którą trzeba zatrzymać, aby możliwe było uruchomienie nowej."</string>
    <string name="old_app_action" msgid="493129172238566282">"Powrót do aplikacji <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Nie uruchamiaj nowej aplikacji."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Uruchom <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Zatrzymaj starą aplikację bez zapisywania."</string>
    <string name="dump_heap_notification" msgid="2618183274836056542">"Proces <xliff:g id="PROC">%1$s</xliff:g> przekroczył limit pamięci"</string>
    <string name="dump_heap_notification_detail" msgid="2075673362317481664">"Pobrano zrzut stosu – kliknij, by go udostępnić"</string>
    <string name="dump_heap_title" msgid="5864292264307651673">"Udostępnić zrzut stosu?"</string>
    <string name="dump_heap_text" msgid="4809417337240334941">"Proces <xliff:g id="PROC">%1$s</xliff:g> przekroczył swój limit pamięci, który wynosi <xliff:g id="SIZE">%2$s</xliff:g>. Możesz udostępnić zrzut stosu programiście procesu. Uwaga: ten zrzut może zawierać wszelkie dane osobowe, do których aplikacja ma dostęp."</string>
    <string name="sendText" msgid="5209874571959469142">"Wybierz czynność, jaka ma zostać wykonana na tekście"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Głośność dzwonka"</string>
    <string name="volume_music" msgid="5421651157138628171">"Głośność multimediów"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Odtwarzanie przez Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Ustawiono cichy dzwonek"</string>
    <string name="volume_call" msgid="3941680041282788711">"Głośność podczas połączenia"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Głośność Bluetooth w czasie połączenia"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Głośność alarmu"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Głośność powiadomienia"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Głośność"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Głośność Bluetooth"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Głośność dzwonka"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Głośność w czasie połączenia"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Głośność multimediów"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Głośność powiadomień"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Dzwonek domyślny"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Dzwonek domyślny (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Brak"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Dzwonki"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Nieznany dzwonek"</string>
    <plurals name="wifi_available" formatted="false" msgid="7900333017752027322">
      <item quantity="few">Dostępne są sieci Wi-Fi</item>
      <item quantity="many">Dostępne są sieci Wi-Fi</item>
      <item quantity="other">Dostępne są sieci Wi-Fi</item>
      <item quantity="one">Dostępna jest sieć Wi-Fi</item>
    </plurals>
    <plurals name="wifi_available_detailed" formatted="false" msgid="1140699367193975606">
      <item quantity="few">Dostępne są otwarte sieci Wi-Fi</item>
      <item quantity="many">Dostępne są otwarte sieci Wi-Fi</item>
      <item quantity="other">Dostępne są otwarte sieci Wi-Fi</item>
      <item quantity="one">Dostępna jest otwarta sieć Wi-Fi</item>
    </plurals>
    <string name="wifi_available_sign_in" msgid="9157196203958866662">"Zaloguj się w sieci Wi-Fi"</string>
    <string name="network_available_sign_in" msgid="1848877297365446605">"Zaloguj się do sieci"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_no_internet" msgid="8451173622563841546">"Sieć Wi-Fi nie ma dostępu do internetu"</string>
    <string name="wifi_no_internet_detailed" msgid="7593858887662270131">"Kliknij, by zobaczyć opcje"</string>
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Nie można połączyć się z siecią Wi-Fi."</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" ma powolne połączenie internetowe."</string>
    <string name="wifi_connect_alert_title" msgid="8455846016001810172">"Zezwolić na połączenie?"</string>
    <string name="wifi_connect_alert_message" msgid="6451273376815958922">"Aplikacja %1$s chce połączyć się z siecią Wi-Fi %2$s"</string>
    <string name="wifi_connect_default_application" msgid="7143109390475484319">"Aplikacja"</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Uruchom Wi-Fi Direct. Spowoduje to wyłączenie klienta lub punktu dostępu Wi-Fi."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Nie można uruchomić Wi-Fi Direct."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"Wi-Fi Direct włączone"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Dotknij, aby zmienić ustawienia"</string>
    <string name="accept" msgid="1645267259272829559">"Akceptuj"</string>
    <string name="decline" msgid="2112225451706137894">"Odrzuć"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Wysłano zaproszenie"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Zaproszenie do połączenia"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Od:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Do:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Wpisz wymagany kod PIN:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"Kod PIN:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"Na czas połączenia z <xliff:g id="DEVICE_NAME">%1$s</xliff:g> tablet zostanie tymczasowo odłączony od Wi-Fi"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tv" msgid="3087858235069421128">"Telewizor zostanie tymczasowo odłączony od Wi-Fi, gdy jest podłączony do urządzenia <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"Na czas połączenia z <xliff:g id="DEVICE_NAME">%1$s</xliff:g> telefon zostanie tymczasowo odłączony od Wi-Fi"</string>
    <string name="select_character" msgid="3365550120617701745">"Wstaw znak"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Wysyłanie wiadomości SMS"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"Aplikacja &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; wysyła wiele SMS-ów. Chcesz pozwolić tej aplikacji dalej wysyłać SMS-y?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Pozwól"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Odmów"</string>
    <string name="sms_short_code_confirm_message" msgid="1645436466285310855">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; chce wysłać wiadomość do &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="5873295990846059400">"To "<b>"może spowodować naliczenie opłat"</b>" przez operatora komórkowego."</string>
    <string name="sms_premium_short_code_details" msgid="7869234868023975"><b>"Spowoduje to naliczanie opłat przez operatora komórkowego."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Wyślij"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Anuluj"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Zapamiętaj mój wybór"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"Możesz to zmienić: Ustawienia &gt; Aplikacje"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Zawsze zezwalaj"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Nigdy nie zezwalaj"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"Karta SIM wyjęta"</string>
    <string name="sim_removed_message" msgid="5450336489923274918">"Sieć komórkowa będzie niedostępna do chwili, gdy ponownie uruchomisz urządzenie po włożeniu ważnej karty SIM."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Gotowe"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"Dodano kartę SIM"</string>
    <string name="sim_added_message" msgid="7797975656153714319">"Uruchom urządzenie ponownie, by uzyskać dostęp do sieci komórkowej."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Uruchom ponownie"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Ustaw godzinę"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Ustaw datę"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Ustaw"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Gotowe"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"NOWE: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Dostarczane przez <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Nie są wymagane żadne uprawnienia"</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"to może generować dodatkowe koszty"</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"Pamięć masowa USB"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"Połączenie przez USB"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"Nawiązano połączenie z komputerem przez USB. Jeśli chcesz skopiować pliki między komputerem a nośnikiem USB systemu Android, dotknij poniższego przycisku."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"Nawiązano połączenie z komputerem przez USB. Jeśli chcesz skopiować pliki między komputerem a kartą SD systemu Android, dotknij poniższego przycisku."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Włącz nośnik USB"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Wystąpił problem z użyciem nośnika USB jako pamięci masowej USB."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Wystąpił problem z użyciem karty SD jako nośnika pamięci masowej USB."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"Połączenie przez USB"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Dotknij, aby skopiować pliki do/z komputera."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Wyłącz nośnik USB"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Dotknij, aby wyłączyć nośnik USB."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"Nośnik USB w użyciu"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Przed wyłączeniem nośnika USB odłącz („wyjmij”) nośnik USB systemu Android od komputera."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Przed wyłączeniem nośnika USB odłącz („wyjmij”) kartę SD systemu Android od komputera."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Wyłącz nośnik USB"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Wystąpił problem podczas wyłączania nośnika USB. Sprawdź, czy host USB został odłączony, a następnie spróbuj ponownie."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Włącz nośnik USB"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Po włączeniu nośnika USB niektóre używane aplikacje zostaną zatrzymane i mogą być niedostępne do chwili jego wyłączenia."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"Operacja USB zakończona niepowodzeniem"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"OK"</string>
    <string name="usb_charging_notification_title" msgid="4004114449249406402">"USB w trybie ładowania"</string>
    <string name="usb_mtp_notification_title" msgid="8396264943589760855">"USB w trybie przesyłania plików"</string>
    <string name="usb_ptp_notification_title" msgid="1347328437083192112">"USB w trybie przesyłania zdjęć"</string>
    <string name="usb_midi_notification_title" msgid="4850904915889144654">"USB w trybie MIDI"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Podłączono jako nośnik instalacyjny."</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Podłączono akcesorium USB"</string>
    <string name="usb_notification_message" msgid="7347368030849048437">"Kliknij, by zobaczyć więcej opcji."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Czy sformatować nośnik USB?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Czy sformatować kartę SD?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Wszystkie pliki zapisane na nośniku USB zostaną usunięte. Tej czynności nie można cofnąć."</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Wszystkie dane na karcie zostaną utracone."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Formatuj"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"Podłączono moduł debugowania USB"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Dotknij, aby wyłączyć debugowanie USB."</string>
    <string name="select_input_method" msgid="8547250819326693584">"Zmień klawiaturę"</string>
    <string name="configure_input_methods" msgid="4769971288371946846">"Wybierz klawiatury"</string>
    <string name="show_ime" msgid="9157568568695230830">"Pokaż metodę wprowadzania"</string>
    <string name="hardware" msgid="7517821086888990278">"Sprzęt"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Wybierz układ klawiatury"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Kliknij, by wybrać układ klawiatury."</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"kandydaci"</u></string>
    <string name="ext_media_checking_notification_title" msgid="5734005953288045806">"Przygotowuję: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_checking_notification_message" msgid="4747432538578886744">"Sprawdzanie w poszukiwaniu błędów"</string>
    <string name="ext_media_new_notification_message" msgid="7589986898808506239">"Wykryto nowy nośnik: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_ready_notification_message" msgid="4083398150380114462">"Do przenoszenia zdjęć i multimediów"</string>
    <string name="ext_media_unmountable_notification_title" msgid="8295123366236989588">"Nośnik <xliff:g id="NAME">%s</xliff:g> uszkodzony"</string>
    <string name="ext_media_unmountable_notification_message" msgid="1586311304430052169">"Nośnik <xliff:g id="NAME">%s</xliff:g> jest uszkodzony. Kliknij, by go naprawić."</string>
    <string name="ext_media_unsupported_notification_title" msgid="3797642322958803257">"Nośnik <xliff:g id="NAME">%s</xliff:g> nieobsługiwany"</string>
    <string name="ext_media_unsupported_notification_message" msgid="8789610369456474891">"To urządzenie nie obsługuje tego nośnika <xliff:g id="NAME">%s</xliff:g>. Kliknij, by skonfigurować go w obsługiwanym formacie."</string>
    <string name="ext_media_badremoval_notification_title" msgid="3206248947375505416">"<xliff:g id="NAME">%s</xliff:g>: nieoczekiwane wyjęcie"</string>
    <string name="ext_media_badremoval_notification_message" msgid="380176703346946313">"Odłącz nośnik <xliff:g id="NAME">%s</xliff:g> przed jego wyjęciem, by uniknąć utraty danych"</string>
    <string name="ext_media_nomedia_notification_title" msgid="1704840188641749091">"Wyjęto: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_nomedia_notification_message" msgid="6471542972147056586">"Wyjęto nośnik <xliff:g id="NAME">%s</xliff:g>. Włóż nowy"</string>
    <string name="ext_media_unmounting_notification_title" msgid="640674168454809372">"Nadal wysuwam: <xliff:g id="NAME">%s</xliff:g>…"</string>
    <string name="ext_media_unmounting_notification_message" msgid="4182843895023357756">"Nie wyjmuj"</string>
    <string name="ext_media_init_action" msgid="7952885510091978278">"Skonfiguruj"</string>
    <string name="ext_media_unmount_action" msgid="1121883233103278199">"Odłącz"</string>
    <string name="ext_media_browse_action" msgid="8322172381028546087">"Przeglądaj"</string>
    <string name="ext_media_missing_title" msgid="620980315821543904">"Brak: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_missing_message" msgid="5761133583368750174">"Ponownie włóż urządzenie"</string>
    <string name="ext_media_move_specific_title" msgid="1471100343872375842">"Przenoszę <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_title" msgid="1022809140035962662">"Przenoszę dane"</string>
    <string name="ext_media_move_success_title" msgid="8575300932957954671">"Przenoszenie zakończone"</string>
    <string name="ext_media_move_success_message" msgid="4199002148206265426">"Dane przeniesione na: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="7613189040358789908">"Nie udało się przenieść danych"</string>
    <string name="ext_media_move_failure_message" msgid="1978096440816403360">"Dane pozostały w oryginalnej lokalizacji"</string>
    <string name="ext_media_status_removed" msgid="6576172423185918739">"Usunięto"</string>
    <string name="ext_media_status_unmounted" msgid="2551560878416417752">"Odłączone"</string>
    <string name="ext_media_status_checking" msgid="6193921557423194949">"Sprawdzam…"</string>
    <string name="ext_media_status_mounted" msgid="7253821726503179202">"Gotowe"</string>
    <string name="ext_media_status_mounted_ro" msgid="8020978752406021015">"Tylko do odczytu"</string>
    <string name="ext_media_status_bad_removal" msgid="8395398567890329422">"Usunięto nieprawidłowo"</string>
    <string name="ext_media_status_unmountable" msgid="805594039236667894">"Uszkodzone"</string>
    <string name="ext_media_status_unsupported" msgid="4691436711745681828">"Nieobsługiwane"</string>
    <string name="ext_media_status_ejecting" msgid="5463887263101234174">"Odłączam…"</string>
    <string name="ext_media_status_formatting" msgid="1085079556538644861">"Formatuję…"</string>
    <string name="ext_media_status_missing" msgid="5638633895221670766">"Nie podłączono"</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Nie znaleziono pasujących działań."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Kierowanie wyjścia multimediów"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Pozwala aplikacji na kierowanie wyjściowych danych multimedialnych do innych urządzeń zewnętrznych."</string>
    <string name="permlab_readInstallSessions" msgid="6165432407628065939">"Odczyt sesji instalacji"</string>
    <string name="permdesc_readInstallSessions" msgid="2049771699626019849">"Pozwala aplikacji odczytywać sesje instalacji. Umożliwia to jej na poznanie szczegółów aktywnych instalacji pakietów."</string>
    <string name="permlab_requestInstallPackages" msgid="1772330282283082214">"Żądanie instalacji pakietów"</string>
    <string name="permdesc_requestInstallPackages" msgid="5740101072486783082">"Zezwala aplikacji żądanie instalacji pakietów."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Dotknij dwukrotnie, aby sterować powiększeniem."</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Nie można dodać widżetu."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"OK"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Szukaj"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Wyślij"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Dalej"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Gotowe"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Wstecz"</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Wykonaj"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Połącz\nz numerem <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Utwórz kontakt\ndla numeru <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Co najmniej jedna z następujących aplikacji żąda uprawnień dostępu do Twojego konta – teraz i w przyszłości."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Chcesz zezwolić na to żądanie?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Prośba o dostęp"</string>
    <string name="allow" msgid="7225948811296386551">"Zezwól"</string>
    <string name="deny" msgid="2081879885755434506">"Odmów"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Prośba o pozwolenie"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Prośba o pozwolenie\ndotyczące konta <xliff:g id="ACCOUNT">%s</xliff:g>"</string>
    <string name="forward_intent_to_owner" msgid="1207197447013960896">"Używasz tej aplikacji poza profilem do pracy"</string>
    <string name="forward_intent_to_work" msgid="621480743856004612">"Używasz tej aplikacji w swoim profilu do pracy"</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Sposób wprowadzania tekstu"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Synchronizacja"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Ułatwienia dostępu"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Tapeta"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Zmień tapetę"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Odbiornik powiadomień"</string>
    <string name="condition_provider_service_binding_label" msgid="1321343352906524564">"Dostawca warunków"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN aktywny"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"Obsługa sieci VPN została włączona przez aplikację <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="3011306607126450322">"Dotknij, aby zarządzać siecią."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Nawiązano połączenie z: <xliff:g id="SESSION">%s</xliff:g>. Dotknij, aby zarządzać siecią."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Łączę ze stałą siecią VPN…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Połączono ze stałą siecią VPN"</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Błąd stałej sieci VPN"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Kliknij, by skonfigurować"</string>
    <string name="upload_file" msgid="2897957172366730416">"Wybierz plik"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Nie wybrano pliku"</string>
    <string name="reset" msgid="2448168080964209908">"Resetuj"</string>
    <string name="submit" msgid="1602335572089911941">"Prześlij"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Tryb samochodowy włączony"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Dotknij, aby zamknąć tryb samochodowy."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Aktywny tethering lub punkt dostępu"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Dotknij, aby skonfigurować."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Wróć"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Dalej"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Pomiń"</string>
    <string name="no_matches" msgid="8129421908915840737">"Brak wyników"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Znajdź na stronie"</string>
    <plurals name="matches_found" formatted="false" msgid="1210884353962081884">
      <item quantity="few"><xliff:g id="INDEX">%d</xliff:g> z <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="many"><xliff:g id="INDEX">%d</xliff:g> z <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="other"><xliff:g id="INDEX">%d</xliff:g> z <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="one">1 dopasowanie</item>
    </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Gotowe"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"Odłączanie nośnika USB..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"Odłączanie karty SD..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Czyszczenie nośnika USB..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Czyszczenie karty SD..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Nie można wymazać pamięci USB."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Nie można wymazać karty SD."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"Karta SD została wyjęta przed jej odłączeniem."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"Nośnik USB jest obecnie sprawdzany."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"Karta SD jest obecnie sprawdzana."</string>
    <string name="media_removed" msgid="7001526905057952097">"Karta SD została wyjęta."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"Nośnik USB jest obecnie używany przez komputer."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"Karta SD jest obecnie używana przez komputer."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Nośnik zewnętrzny jest w nieznanym stanie."</string>
    <string name="share" msgid="1778686618230011964">"Udostępnij"</string>
    <string name="find" msgid="4808270900322985960">"Znajdź"</string>
    <string name="websearch" msgid="4337157977400211589">"Wyszukiwarka"</string>
    <string name="find_next" msgid="5742124618942193978">"Znajdź następne"</string>
    <string name="find_previous" msgid="2196723669388360506">"Znajdź poprzednie"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Prośba o lokalizację od użytkownika <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Prośba o lokalizację"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Żądane przez <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Tak"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Nie"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Przekroczono limit usuwania"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Usuwasz <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> elementy(ów) przez: <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> (konto: <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>). Co chcesz zrobić?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Usuń elementy."</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Cofnij usunięcia"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Nie wykonuj teraz żadnych czynności."</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Wybierz konto"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Dodaj konto"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Dodaj konto"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Zwiększ"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Zmniejsz"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"<xliff:g id="VALUE">%s</xliff:g> dotknij i przytrzymaj."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Przesuń w górę, by zwiększyć, i w dół, by zmniejszyć."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Zmień minutę na późniejszą"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Zmień minutę na wcześniejszą"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Zmień godzinę na późniejszą"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Zmień godzinę na wcześniejszą"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Ustaw PM"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Ustaw AM"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Zmień miesiąc na późniejszy"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Zmień miesiąc na wcześniejszy"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Zmień dzień na późniejszy"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Zmień dzień na wcześniejszy"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Zmień rok na późniejszy"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Zmień rok na wcześniejszy"</string>
    <string name="date_picker_prev_month_button" msgid="2858244643992056505">"Poprzedni miesiąc"</string>
    <string name="date_picker_next_month_button" msgid="5559507736887605055">"Następny miesiąc"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Anuluj"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Delete"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Gotowe"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Zmiana trybu"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Enter"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Wybierz aplikację"</string>
    <string name="activitychooserview_choose_application_error" msgid="8624618365481126668">"Nie udało się uruchomić aplikacji <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Udostępnij przez"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Udostępnij przez <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Uchwyt przesuwny. Dotknij i przytrzymaj."</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Przesuń, aby odblokować."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Podłącz zestaw słuchawkowy, aby wysłuchać znaków hasła wypowiadanych na głos."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Kropka"</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Przejdź do strony głównej"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Przejdź wyżej"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Więcej opcji"</string>
    <string name="action_bar_home_description_format" msgid="7965984360903693903">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="6985546530471780727">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="4891916833657929263">"Pamięć wewnętrzna"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"Karta SD"</string>
    <string name="storage_sd_card_label" msgid="6347111320774379257">"Karta SD (<xliff:g id="MANUFACTURER">%s</xliff:g>)"</string>
    <string name="storage_usb_drive" msgid="6261899683292244209">"Dysk USB"</string>
    <string name="storage_usb_drive_label" msgid="4501418548927759953">"Dysk USB (<xliff:g id="MANUFACTURER">%s</xliff:g>)"</string>
    <string name="storage_usb" msgid="3017954059538517278">"Nośnik USB"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Ostrzeżenie o transmisji danych"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Dotknij – użycie i ustawienia."</string>
    <string name="data_usage_3g_limit_title" msgid="4361523876818447683">"Osiągnięto limit danych 2G/3G"</string>
    <string name="data_usage_4g_limit_title" msgid="4609566827219442376">"Osiągnięto limit danych 4G"</string>
    <string name="data_usage_mobile_limit_title" msgid="557158376602636112">"Osiągnięto limit danych komórkowych"</string>
    <string name="data_usage_wifi_limit_title" msgid="5803363779034792676">"Osiągnięto limit danych Wi-Fi"</string>
    <string name="data_usage_limit_body" msgid="291731708279614081">"Dane wstrzymane do końca cyklu"</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"Przekroczono limit danych 2G/3G"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"Przekroczono limit danych 4G"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="4941346653729943789">"Przekroczono limit danych komórk."</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Przekroczono limit danych Wi-Fi"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> ponad określony limit"</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Dane w tle są ograniczone"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Dotknij, by usunąć ograniczenie."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Certyfikat zabezpieczeń"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Certyfikat jest ważny."</string>
    <string name="issued_to" msgid="454239480274921032">"Wystawiony dla:"</string>
    <string name="common_name" msgid="2233209299434172646">"Nazwa (CN):"</string>
    <string name="org_name" msgid="6973561190762085236">"Organizacja:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Jednostka organizacyjna:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Wystawca:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Ważność:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Wystawiony:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Wygasa:"</string>
    <string name="serial_number" msgid="758814067660862493">"Numer seryjny:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Odciski cyfrowe:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"Odcisk cyfrowy SHA-256:"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"Odcisk cyfrowy SHA-1:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Zobacz wszystkie"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Wybierz działanie"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Udostępnij przez"</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Wysyłanie..."</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Uruchomić przeglądarkę?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Odebrać połączenie?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Zawsze"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Tylko raz"</string>
    <string name="activity_resolver_work_profiles_support" msgid="185598180676883455">"%1$s nie obsługuje profilu do pracy"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tablet"</string>
    <string name="default_audio_route_name" product="tv" msgid="9158088547603019321">"Telewizor"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefon"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Słuchawki"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Głośniki stacji dokującej"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"System"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Dźwięk Bluetooth"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Wyświetlacz bezprzewodowy"</string>
    <string name="media_route_button_content_description" msgid="591703006349356016">"Przesyłaj"</string>
    <string name="media_route_chooser_title" msgid="1751618554539087622">"Połącz z urządzeniem"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3395541745872017583">"Prześlij ekran na urządzenie"</string>
    <string name="media_route_chooser_searching" msgid="4776236202610828706">"Szukam urządzeń…"</string>
    <string name="media_route_chooser_extended_settings" msgid="87015534236701604">"Ustawienia"</string>
    <string name="media_route_controller_disconnect" msgid="8966120286374158649">"Rozłącz"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Skanuję..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Łączę..."</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"Dostępne"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Niedostępne"</string>
    <string name="media_route_status_in_use" msgid="4533786031090198063">"W użyciu"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Wbudowany ekran"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"Ekran HDMI"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Nakładka nr <xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="652124517672257172">"<xliff:g id="NAME">%1$s</xliff:g>: <xliff:g id="WIDTH">%2$d</xliff:g> x <xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> dpi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="6022119702628572080">", bezpieczny"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Nie pamiętam wzoru"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Nieprawidłowy wzór"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Nieprawidłowe hasło"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Nieprawidłowy PIN"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Spróbuj ponownie za <xliff:g id="NUMBER">%1$d</xliff:g> s."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Narysuj wzór"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Podaj PIN karty SIM"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Podaj PIN"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Wpisz hasło"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"Karta SIM została wyłączona. Podaj kod PUK, by przejść dalej. Szczegóły uzyskasz od operatora."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Podaj wybrany kod PIN"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Potwierdź wybrany kod PIN"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"Odblokowuję kartę SIM…"</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"Nieprawidłowy PIN."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Wpisz PIN o długości od 4 do 8 cyfr."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="6025069204539532000">"PUK musi mieć 8 cyfr."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Ponownie podaj poprawny kod PUK. Nieudane próby spowodują trwałe wyłączenie karty SIM."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"Kody PIN nie pasują"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Zbyt wiele prób narysowania wzoru"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Aby odblokować, zaloguj się na konto Google."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Nazwa użytkownika (e-mail)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Hasło"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Zaloguj się"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Nieprawidłowa nazwa użytkownika lub hasło."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Nie pamiętasz nazwy użytkownika lub hasła?\nWejdź na "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Sprawdzam konto"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"Wpisałeś nieprawidłowy kod PIN <xliff:g id="NUMBER_0">%d</xliff:g> razy. \n\nSpróbuj ponownie za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"Po raz <xliff:g id="NUMBER_0">%d</xliff:g> wpisałeś nieprawidłowe hasło. \n\nSpróbuj ponownie za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"Narysowałeś nieprawidłowy wzór odblokowania <xliff:g id="NUMBER_0">%d</xliff:g> razy. \n\nSpróbuj ponownie za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"Po raz <xliff:g id="NUMBER_0">%d</xliff:g> próbowałeś nieprawidłowo odblokować tablet. Po kolejnych <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach tablet zostanie zresetowany do ustawień fabrycznych, a wszystkie dane użytkownika zostaną utracone."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tv" msgid="5621231220154419413">"Podałeś nieprawidłowe dane odblokowania telewizora <xliff:g id="NUMBER_0">%d</xliff:g> razy. Po jeszcze <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach telewizor zostanie zresetowany do stanu fabrycznego, a wszystkie dane użytkownika zostaną skasowane."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"Po raz <xliff:g id="NUMBER_0">%d</xliff:g> próbowałeś nieprawidłowo odblokować telefon. Po kolejnych <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach telefon zostanie zresetowany do ustawień fabrycznych, a wszystkie dane użytkownika zostaną utracone."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"Po raz <xliff:g id="NUMBER">%d</xliff:g> próbowałeś nieprawidłowo odblokować tablet. Tablet zostanie teraz zresetowany do ustawień fabrycznych."</string>
    <string name="kg_failed_attempts_now_wiping" product="tv" msgid="4987878286750741463">"Podałeś nieprawidłowe dane odblokowania telewizora <xliff:g id="NUMBER">%d</xliff:g> razy. Zostanie on teraz zresetowany do stanu fabrycznego."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"Po raz <xliff:g id="NUMBER">%d</xliff:g> próbowałeś nieprawidłowo odblokować telefon. Telefon zostanie teraz zresetowany do ustawień fabrycznych."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"Po raz <xliff:g id="NUMBER_0">%d</xliff:g> nieprawidłowo narysowałeś wzór odblokowania. Po kolejnych <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach konieczne będzie odblokowanie tabletu przy użyciu danych logowania na konto Google.\n\n Spróbuj ponownie za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="4224651132862313471">"Wzór odblokowania narysowałeś niepoprawnie <xliff:g id="NUMBER_0">%d</xliff:g> razy. Po jeszcze <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach trzeba będzie odblokować telewizor przy użyciu konta e-mail.\n\n Spróbuj ponownie za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"Po raz <xliff:g id="NUMBER_0">%d</xliff:g> nieprawidłowo narysowałeś wzór odblokowania. Po kolejnych <xliff:g id="NUMBER_1">%d</xliff:g> nieudanych próbach konieczne będzie odblokowanie telefonu przy użyciu danych logowania na konto Google.\n\n Spróbuj ponownie za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" – "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Usuń"</string>
    <string name="safe_media_volume_warning" product="default" msgid="2276318909314492312">"Zwiększyć głośność ponad zalecany poziom?\n\nSłuchanie głośno przez długi czas może uszkodzić Twój słuch."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Aby włączyć ułatwienia dostępu, przytrzymaj dwa palce."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Włączono ułatwienia dostępu."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Ułatwienia dostępu zostały anulowane."</string>
    <string name="user_switched" msgid="3768006783166984410">"Bieżący użytkownik: <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="user_switching_message" msgid="2871009331809089783">"Przełączam na użytkownika <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="owner_name" msgid="2716755460376028154">"Właściciel"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Błąd"</string>
    <string name="error_message_change_not_allowed" msgid="1347282344200417578">"Ta zmiana nie jest dozwolona przez administratora"</string>
    <string name="app_not_found" msgid="3429141853498927379">"Nie znaleziono aplikacji do obsługi tej akcji"</string>
    <string name="revoke" msgid="5404479185228271586">"Cofnij"</string>
    <string name="mediasize_iso_a0" msgid="1994474252931294172">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="3333060421529791786">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="3097535991925798280">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3023213259314236123">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="231745325296873764">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3484327407340865411">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="4861908487129577530">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="5890208588072936130">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="4319425041085816612">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="4882220529506432008">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="2382866026365359391">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="3651827147402009675">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="6072859628278739957">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="1348731852150380378">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="2612510181259261379">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="695151378838115434">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="4863754285582212487">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="5305816292139647241">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="531673542602786624">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="9164474595708850034">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="282102976764774160">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="4517141714407898976">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="3103521357901591100">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1231954105985048595">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="927702816980087462">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="835154173518304159">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="5095951985108194011">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="1985397450332305739">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8147421924174693013">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="8993994925276122950">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="6871178104139598957">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="7983532635227561362">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="5040764293406765584">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="2841414839888344296">"Letter"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="5295836838862962809">"Government Letter"</string>
    <string name="mediasize_na_legal" msgid="8621364037680465666">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3309324162155085904">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="5567030340509075333">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="4571735038501661757">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="5182901917818625126">"Index Card 3x5"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"Index Card 4x6"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"Index Card 5x8"</string>
    <string name="mediasize_na_monarch" msgid="213639906956550754">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="835778493593023223">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="1573911237983677138">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="3626855847189438896">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="9182191577022943355">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="4793232644980170500">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="5404109730975720670">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1335092253339363526">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="9167997800486569834">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="845875168823541497">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3220325667692648789">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="1776792138507038527">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="1417176642687456692">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="4785983473123798365">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7847982299391851899">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="262793383539980677">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="5256815579447959814">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="7336412963441354407">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="6324465444100490742">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="1787262845627694376">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="3336035783663287470">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="6195398299104345731">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="1674621886902828884">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4170576286062657435">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="4899297958100032533">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="4213158129126666847">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="8513715307410310696">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="4777690211897131190">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="4608142385457034603">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="7587108366572243991">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="5244075432263649068">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="4941652015032631361">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="6387319169263957010">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="1299112025415343982">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="8070115620644254565">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="6049065587307896564">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="6872696027560065173">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="2359077233775455405">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="2091777168747058008">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3088043641616409762">"Nieznany pionowy"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Nieznany poziomy"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Anulowane"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Błąd podczas zapisu treści"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"brak informacji"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Nie jest włączona usługa drukowania"</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"Usługa <xliff:g id="NAME">%s</xliff:g> zainstalowana"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Dotknij, by włączyć"</string>
    <string name="restr_pin_enter_admin_pin" msgid="783643731895143970">"Podaj PIN administratora"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Podaj PIN"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Nieprawidłowy"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Bieżący PIN"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"Nowy PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Potwierdź nowy PIN"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Utwórz PIN wymagany przy zmianie ograniczeń"</string>
    <string name="restr_pin_error_doesnt_match" msgid="2224214190906994548">"Kody PIN nie są identyczne. Spróbuj ponownie."</string>
    <string name="restr_pin_error_too_short" msgid="8173982756265777792">"PIN jest za krótki. Musi mieć co najmniej 4 cyfry."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="9061246974881224688">
      <item quantity="few">Spróbuj ponownie za <xliff:g id="COUNT">%d</xliff:g> sekundy</item>
      <item quantity="many">Spróbuj ponownie za <xliff:g id="COUNT">%d</xliff:g> sekund</item>
      <item quantity="other">Spróbuj ponownie za <xliff:g id="COUNT">%d</xliff:g> sekundy</item>
      <item quantity="one">Spróbuj ponownie za sekundę</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="973144472490532377">"Spróbuj ponownie później"</string>
    <string name="immersive_cling_title" msgid="8394201622932303336">"Widok na pełnym ekranie"</string>
    <string name="immersive_cling_description" msgid="3482371193207536040">"Aby wyjść, przesuń palcem z góry na dół."</string>
    <string name="immersive_cling_positive" msgid="5016839404568297683">"OK"</string>
    <string name="done_label" msgid="2093726099505892398">"Gotowe"</string>
    <string name="hour_picker_description" msgid="6698199186859736512">"Kołowy suwak godzin"</string>
    <string name="minute_picker_description" msgid="8606010966873791190">"Kołowy suwak minut"</string>
    <string name="select_hours" msgid="6043079511766008245">"Wybierz godziny"</string>
    <string name="select_minutes" msgid="3974345615920336087">"Wybierz minuty"</string>
    <string name="select_day" msgid="7774759604701773332">"Wybierz miesiąc i dzień"</string>
    <string name="select_year" msgid="7952052866994196170">"Wybierz rok"</string>
    <string name="deleted_key" msgid="7659477886625566590">"<xliff:g id="KEY">%1$s</xliff:g> usunięte"</string>
    <string name="managed_profile_label_badge" msgid="2355652472854327647">"<xliff:g id="LABEL">%1$s</xliff:g> (praca)"</string>
    <string name="lock_to_app_toast" msgid="7570091317001980053">"Aby odpiąć ten ekran, naciśnij i przytrzymaj jednocześnie Wstecz i Przegląd."</string>
    <string name="lock_to_app_toast_accessible" msgid="8239120109365070664">"Aby odpiąć ten ekran, naciśnij i przytrzymaj Przegląd."</string>
    <string name="lock_to_app_toast_locked" msgid="9125176335701699164">"Aplikacja jest przypięta. Nie możesz jej odpiąć na tym urządzeniu."</string>
    <string name="lock_to_app_start" msgid="6643342070839862795">"Ekran przypięty"</string>
    <string name="lock_to_app_exit" msgid="8598219838213787430">"Ekran odpięty"</string>
    <string name="lock_to_app_unlock_pin" msgid="2552556656504331634">"Podaj PIN, aby odpiąć"</string>
    <string name="lock_to_app_unlock_pattern" msgid="4182192144797225137">"Aby odpiąć, poproś o wzór odblokowania"</string>
    <string name="lock_to_app_unlock_password" msgid="6380979775916974414">"Aby odpiąć, poproś o hasło"</string>
    <string name="package_installed_device_owner" msgid="8420696545959087545">"Zainstalowany przez administratora"</string>
    <string name="package_updated_device_owner" msgid="8856631322440187071">"Zaktualizowane przez administratora"</string>
    <string name="package_deleted_device_owner" msgid="7650577387493101353">"Usunięty przez administratora"</string>
    <string name="battery_saver_description" msgid="1960431123816253034">"Aby wydłużyć czas pracy baterii, Oszczędzanie baterii ogranicza aktywność urządzenia, w tym wibracje, usługi lokalizacyjne i przetwarzanie większości danych w tle. Poczta, czat i inne synchronizowane aplikacje mogą nie aktualizować swojej zawartości, dopóki ich nie otworzysz.\n\nOszczędzanie baterii wyłącza się automatycznie podczas ładowania urządzenia."</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="4367877408072000848">
      <item quantity="few">Przez %1$d minuty (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">Przez %1$d minut (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Przez %1$d minuty (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Przez minutę (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="6830154222366042597">
      <item quantity="few">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">1 min (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="8152974162096743862">
      <item quantity="few">Przez %1$d godziny (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">Przez %1$d godzin (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Przez %1$d godziny (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Przez godzinę (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="4787552595253082371">
      <item quantity="few">%1$d godz. (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d godz. (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d godz. (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">1 godz. (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="5127407202506485571">
      <item quantity="few">Przez %d minuty</item>
      <item quantity="many">Przez %d minut</item>
      <item quantity="other">Przez %d minuty</item>
      <item quantity="one">Przez minutę</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2199350154433426128">
      <item quantity="few">%d min</item>
      <item quantity="many">%d min</item>
      <item quantity="other">%d min</item>
      <item quantity="one">1 min</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="3938821308277433854">
      <item quantity="few">Przez %d godziny</item>
      <item quantity="many">Przez %d godzin</item>
      <item quantity="other">Przez %d godziny</item>
      <item quantity="one">Przez godzinę</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="6748277774662434217">
      <item quantity="few">%d godz.</item>
      <item quantity="many">%d godz.</item>
      <item quantity="other">%d godz.</item>
      <item quantity="one">1 godz.</item>
    </plurals>
    <string name="zen_mode_until" msgid="7336308492289875088">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_forever" msgid="7420011936770086993">"Dopóki nie wyłączysz"</string>
    <string name="zen_mode_forever_dnd" msgid="3792132696572189081">"Do wyłączenia Nie przeszkadzać"</string>
    <string name="zen_mode_rule_name_combination" msgid="191109939968076477">"<xliff:g id="FIRST">%1$s</xliff:g> / <xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="2821479483960330739">"Zwiń"</string>
    <string name="zen_mode_feature_name" msgid="5254089399895895004">"Nie przeszkadzać"</string>
    <string name="zen_mode_downtime_feature_name" msgid="2626974636779860146">"Powiadomienia wyłączone"</string>
    <string name="zen_mode_default_weeknights_name" msgid="3081318299464998143">"Noc poza weekendem"</string>
    <string name="zen_mode_default_weekends_name" msgid="2786495801019345244">"Weekend"</string>
    <string name="zen_mode_default_events_name" msgid="8158334939013085363">"Wydarzenie"</string>
    <string name="muted_by" msgid="6147073845094180001">"Ściszone przez: <xliff:g id="THIRD_PARTY">%1$s</xliff:g>"</string>
    <string name="system_error_wipe_data" msgid="6608165524785354962">"W Twoim urządzeniu wystąpił problem wewnętrzny. Może być ono niestabilne, dopóki nie przywrócisz danych fabrycznych."</string>
    <string name="system_error_manufacturer" msgid="8086872414744210668">"W Twoim urządzeniu wystąpił problem wewnętrzny. Skontaktuj się z jego producentem, by otrzymać szczegółowe informacje."</string>
    <string name="stk_cc_ussd_to_dial" msgid="5202342984749947872">"Żądanie USSD zostało zmienione na żądanie DIAL."</string>
    <string name="stk_cc_ussd_to_ss" msgid="2345360594181405482">"Żądanie USSD zostało zmienione na żądanie SS."</string>
    <string name="stk_cc_ussd_to_ussd" msgid="7466087659967191653">"Żądanie USSD zostało zmienione na nowe żądanie USSD."</string>
    <string name="stk_cc_ss_to_dial" msgid="2151304435775557162">"Żądanie SS zostało zmienione na żądanie DIAL."</string>
    <string name="stk_cc_ss_to_ussd" msgid="3951862188105305589">"Żądanie SS zostało zmienione na żądanie USSD."</string>
    <string name="stk_cc_ss_to_ss" msgid="5470768854991452695">"Żądanie SS zostało zmienione na nowe żądanie SS."</string>
    <string name="notification_work_profile_content_description" msgid="4600554564103770764">"Profil do pracy"</string>
    <string name="usb_midi_peripheral_name" msgid="7221113987741003817">"Port peryferyjny USB na urządzeniu z Androidem"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7176526170008970168">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="4971827859165280403">"Port peryferyjny USB"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="4797287862999444631">"Więcej opcji"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="559796923090723804">"Zamknij rozszerzony pasek"</string>
    <!-- no translation found for selected_count (7187339492915744615) -->
</resources>
