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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Tak"</string>
    <string name="no" msgid="6731231425810196216">"Nie"</string>
    <string name="create" msgid="3578857613172647409">"Utwórz"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Nieznany"</string>
    <string name="header_category_wireless_networks" msgid="4944823405420438623">"SIECI ZWYKŁE I BEZPRZEWODOWE"</string>
    <string name="header_category_device" msgid="5781174212691167553">"URZĄDZENIE"</string>
    <string name="header_category_personal" msgid="6225932173498802187">"OSOBISTE"</string>
    <string name="header_category_system" msgid="2073558547468647128">"SYSTEM"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Włącz radio"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Wyłącz radio"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Włącz SMS przez IMS"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Wyłącz SMS przez IMS"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Włącz wymóg rejestracji IMS"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Wyłącz wymóg rejestracji IMS"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Włącz zrzut pamięci RAM LTE"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Wyłącz zrzut pamięci RAM LTE"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Wyświetl książkę adresową na karcie SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Wyświetl ustalone numery"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Wyświetl numery usług"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Pobierz listę PDP"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"Działa"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Nie działa"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Tylko połączenia alarmowe"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Radio wyłączone"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Brak roamingu"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Bezczynny"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Dzwonienie"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Połączenie w toku"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Rozłączona"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Łączenie"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Połączony"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Zawieszony"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"nieznane"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pakietów"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajtów"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Odłącz nośnik USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Odłącz kartę SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Wyczyść nośnik USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Wyczyść kartę SD"</string>
    <string name="small_font" msgid="2295331917424072635">"Mały"</string>
    <string name="medium_font" msgid="2068475425515133701">"Średni"</string>
    <string name="large_font" msgid="599055175160971446">"Duży"</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Nośnik USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Karta SD"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"Stan baterii:"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Podłączone zasilanie:"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Poziom baterii:"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Poziom naładowania baterii:"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"Poziom baterii:"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Technologia wykonania baterii:"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Napięcie baterii:"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Temperatura baterii:"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"°C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Czas od uruchomienia:"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Czas działania na baterii:"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Czas pozostawania w stanie wybudzenia podczas ładowania:"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Czas włączenia ekranu:"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Nieznany"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Ładowanie"</string>
    <string name="battery_info_status_charging_ac" msgid="5874340256342956252">"(AC)"</string>
    <string name="battery_info_status_charging_usb" msgid="4059070156126770959">"(USB)"</string>
    <string name="battery_info_status_discharging" msgid="6222697503392774475">"rozładowywanie"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Nie ładuje"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Pełna"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Odłączone"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"Zasilacz"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"Zasilacz i USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Nieznane"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Nieznane"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Dobry"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Przegrzanie"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Rozładowana"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Przepięcie"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Nieznany błąd"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Zimna"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_visibility" msgid="2930835434091839916">"Wykrywalny"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Widoczne dla wszystkich urządzeń Bluetooth (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Widoczne dla wszystkich urządzeń Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Niewidoczne dla innych urządzeń Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Widoczne tylko dla urządzeń sparowanych"</string>
    <string name="bluetooth_not_discoverable" msgid="128269993123955177">"Zezwalaj na wykrywanie urządzenia"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Czas widoczności"</string>
    <string name="bluetooth_visibility_timeout_summary" msgid="6483353842671501585">"Ustaw czas, przez jaki urządzenie będzie wykrywalne"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Zablokuj wybieranie głosowe"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Zapobiegaj używaniu wybierania Bluetooth, gdy ekran jest zablokowany"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Lista urządzeń"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Nazwa urządzenia"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Ustawienia urządzenia"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Ustawienia profilu"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nie ustawiono nazwy, wykorzystywana jest nazwa konta"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Wyszukaj urządzenia"</string>
    <string name="bluetooth_rename_device" product="tablet" msgid="787970073150631155">"Zmień nazwę tabletu"</string>
    <string name="bluetooth_rename_device" product="default" msgid="6267987985556136749">"Zmień nazwę telefonu"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Zmień nazwę"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Rozłączyć?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"Spowoduje to zakończenie połączenia z urządzeniem:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Wyłączyć profil?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"Spowoduje to wyłączenie profilu:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Urządzenie:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_connected" msgid="6038755206916626419">"Połączony"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Połączono (bez telefonu)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Połączono (bez multimediów)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Połączono (bez telefonu ani multimediów)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Rozłączona"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Rozłączanie..."</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Łączenie..."</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Parowanie..."</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Urządzenie Bluetooth bez nazwy"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Wyszukiwanie"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Brak urządzeń Bluetooth w pobliżu"</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Żądanie parowania Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Żądanie parowania"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Dotknij, by sparować z <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Pokaż odebrane pliki"</string>
    <string name="device_picker" msgid="8398232791303186677">"Wybór urządzenia Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Prośba o pozwolenie na włączenie modułu Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="5279027758886569301">"Aplikacja chce włączyć moduł Bluetooth. Zezwolić?"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4420151924834278808">"Aplikacja na tablecie chce go ustawić jako wykrywalny dla innych urządzeń Bluetooth przez <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Zezwolić?"</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="4478906085771274647">"Aplikacja na telefonie chce go ustawić jako wykrywalny dla innych urządzeń Bluetooth przez <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Zezwolić?"</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8737516188038252313">"Aplikacja na tablecie chce go ustawić jako zawsze wykrywalny dla innych urządzeń Bluetooth. Zezwolić?"</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="7751530664834149084">"Aplikacja na telefonie chce go ustawić jako zawsze wykrywalny dla innych urządzeń Bluetooth. Zezwolić?"</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="8504403125440086020">"Aplikacja na tablecie chce włączyć moduł Bluetooth i ustawić tablet jako wykrywalny dla innych urządzeń przez <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Zezwolić?"</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="3040361003987241057">"Aplikacja na telefonie chce włączyć moduł Bluetooth i ustawić telefon jako wykrywalny dla innych urządzeń przez <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Zezwolić?"</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="7254712987802497615">"Aplikacja na tablecie chce włączyć moduł Bluetooth i ustawić tablet jako wykrywalny dla innych urządzeń. Zezwolić?"</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="3947789545028519103">"Aplikacja na telefonie chce włączyć moduł Bluetooth i ustawić telefon jako wykrywalny dla innych urządzeń. Zezwolić?"</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Włączanie Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Wyłączanie Bluetooth..."</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Połącz automatycznie"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Żądanie nawiązania połączenia Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Dotknij, aby połączyć się z urządzeniem „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>”."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Czy chcesz nawiązać połączenie z urządzeniem „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>”?"</string>
    <string name="bluetooth_phonebook_request" msgid="457033227379858269">"Żądanie dotyczące książki telefonicznej"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s chce uzyskać dostęp do Twoich kontaktów i historii połączeń. Zezwolić %2$s na dostęp?"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Nie pytaj ponownie"</string>
    <string name="date_and_time" msgid="4114084177056654663">"Ustawienia daty i godziny"</string>
    <string name="date_time_12_hour_sample" msgid="3259617262618020574">"1:00 (po południu)"</string>
    <string name="date_time_24_hour_sample" msgid="8916857570746212357">"13:00"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Wybierz strefę czasową"</string>
    <string name="normal_date_format" msgid="7636406984925498359">"Regionalny (<xliff:g id="DATE">%s</xliff:g>)"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Podgląd:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Rozmiar czcionki:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Wyślij <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Rozpocznij <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Konto:"</string>
    <string name="proxy_settings_title" msgid="5912878565897294401">"Ustawienia proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Wyczyść"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Numer portu serwera proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Pomiń proxy dla"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com,mojkomputer.test.com,localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Przywróć domyślne"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Gotowe"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Nazwa hosta serwera proxy"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Uwaga"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Wpisana nazwa hosta jest nieprawidłowa."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"Wpisana lista wykluczeń jest niepoprawnie sformatowana. Wykluczone domeny muszą być rozdzielone przecinkami."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Musisz wypełnić pole portu."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Pole port musi być puste, jeśli pole host jest puste."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Wpisany port jest nieprawidłowy."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Serwer proxy HTTP jest używany przez przeglądarkę, ale inne aplikacje mogą go nie używać."</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Lokalizacja:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"Sąsiadujący CID:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Próby danych:"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"Usługa GPRS:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Przekierowania połączeń:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"Liczba operacji resetowania PPP od momentu uruchomienia:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"GSM rozłącza się:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Obecna sieć:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Postępy danych:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"Otrzymano PPP:"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"Usługa GSM:"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Siła sygnału:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Stan połączenia:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"Wysłano PPP:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Resetowanie radia:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Wiadomość oczekująca:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Numer telefonu:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Wybierz pasmo radiowe"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Typ sieci:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Ustaw preferowany typ sieci:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Wyślij polecenie ping adresu IP:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Nazwa hosta dla operacji ping (www.google.pl):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"Test klienta HTTP:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Przeprowadź test ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Aktualizuj"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Odśwież"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Przełącz sprawdzanie DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informacje/ustawienia specyficzne dla producenta OEM"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Ustaw pasmo GSM/UMTS"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Ładowanie listy pasm..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Ustaw"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Niepowodzenie"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Powodzenie"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Zmiany zostaną wprowadzone po ponownym podłączeniu kabla USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Włącz pamięć masową USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Łącznie bajtów:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Nośnik USB niepodłączony"</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Brak karty SD"</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Dostępnych bajtów:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"Nośnik USB jako pamięć masowa"</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Karta SD jest używana jako pamięć masowa."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"Możesz teraz wyjąć nośnik USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"Możesz teraz wyjąć kartę SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"Wyjęto USB podczas używania."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Karta SD została usunięta, gdy była używana!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Wykorzystanych bajtów:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Trwa skanowanie nośnika USB…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Przeszukiwanie karty SD w poszukiwaniu multimediów..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Nośnik USB tylko do odczytu"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Karta SD jest podłączona tylko do odczytu."</string>
    <string name="skip_label" msgid="47510779345218297">"Pomiń"</string>
    <string name="next_label" msgid="4693520878012668114">"Dalej"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Język"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Wybierz działanie"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacje o urządzeniu"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Informacje o baterii"</string>
    <string name="display_label" msgid="8074070940506840792">"Ekran"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informacje o tablecie"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacje o telefonie"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Nośnik USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Karta SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Ustawienia proxy"</string>
    <string name="cancel" msgid="6859253417269739139">"Anuluj"</string>
    <string name="settings_label" msgid="1626402585530130914">"Ustawienia"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Ustawienia"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Skrót do ustawień"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Tryb samolotowy"</string>
    <string name="radio_controls_title" msgid="6889937359495515769">"Więcej..."</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Sieci zwykłe i bezprzewodowe"</string>
    <string name="radio_controls_summary" msgid="2998818677094465517">"Zarządzaj połączeniami Wi-Fi i Bluetooth, trybem samolotowym, sieciami komórkowymi i VPN."</string>
    <string name="roaming" msgid="3596055926335478572">"Dane w roamingu"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Połącz z usługami transmisji danych w roamingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Połącz z usługami transmisji danych w roamingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Połączenie transmisji danych zostało utracone, ponieważ opuszczono sieć macierzystą przy wyłączonej opcji danych w roamingu."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Włącz"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Z zezwoleniem na roaming danych mogą się wiązać wysokie opłaty roamingowe."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Zezwalać na roaming danych?"</string>
    <string name="networks" msgid="6333316876545927039">"Wybór operatora"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Wybierz operatora sieci."</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Data i czas"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Ustaw datę i godzinę"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Ustaw datę, godzinę, strefę czasową i formaty."</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Automatyczna data i czas"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Użyj czasu podanego przez sieć"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Użyj czasu podanego przez sieć"</string>
    <string name="zone_auto" msgid="334783869352026648">"Auto strefa czasowa"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Użyj strefy czasowej podanej przez sieć"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Użyj strefy czasowej podanej przez sieć"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Format 24-godzinny"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Ustaw godzinę"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Wybierz strefę czasową"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Ustaw datę"</string>
    <string name="date_time_date_format" msgid="6951498879879281102">"Wybierz format daty"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Sortuj alfabetycznie"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Sortuj według strefy czasowej"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Data"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Godzina"</string>
    <string name="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Popraw rozpoznawanie twarzy"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Sprawdzanie, czy użytkownik jest żywym człowiekiem"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Wymagaj mrugnięcia podczas odblokowywania"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Blokuj automatycznie"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"Po <xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> uśpienia"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Pokaż tę informację na ekranie blokady"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Informacje o właścicielu"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Wpisz tekst do wyświetlenia na ekranie blokady."</string>
    <string name="location_settings_title" msgid="8935806698251432196">"Usługi lokalizacyjne"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Zabezpieczenia"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Ustaw funkcję Moja lokalizacja, odblokowywanie ekranu, blokadę karty SIM, blokadę magazynu danych logowania."</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Ustaw funkcję Moja lokalizacja, odblokowywanie ekranu, blokadę magazynu danych logowania"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Hasła"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Szyfrowanie"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Zaszyfruj tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Zaszyfruj telefon"</string>
    <string name="crypt_keeper_encrypt_summary" product="tablet" msgid="6291564408810586">"Wymagaj podania kodu PIN lub hasła w celu odszyfrowania tabletu przy każdym uruchomieniu"</string>
    <string name="crypt_keeper_encrypt_summary" product="default" msgid="514138079795442371">"Wymagaj podania kodu PIN lub hasła w celu odszyfrowania telefonu przy każdym uruchomieniu"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Zaszyfrowane"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="3839235202103924154">"Możesz zaszyfrować swoje konta, ustawienia, pobrane aplikacje i ich dane, multimedia oraz inne pliki. Po zaszyfrowaniu tabletu musisz wpisać numeryczny kod PIN lub hasło do odszyfrowania po każdym włączeniu urządzenia. Tablet można odszyfrować jedynie przez przywrócenie danych fabrycznych i usunięcie wszystkich swoich danych."\n\n"Szyfrowanie może potrwać godzinę lub dłużej. Rozpocznij, gdy bateria jest w pełni naładowana i nie odłączaj tabletu od zasilania do chwili ukończenia szyfrowania. Jeśli proces zostanie przerwany, utracisz część lub nawet wszystkie swoje dane."</string>
    <string name="crypt_keeper_desc" product="default" msgid="7663118199519229502">"Możesz zaszyfrować swoje konta, ustawienia, pobrane aplikacje i ich dane, multimedia oraz inne pliki. Po zaszyfrowaniu telefonu musisz wpisać numeryczny kod PIN lub hasło do odszyfrowania po każdym włączeniu urządzenia. Telefon można odszyfrować jedynie przez przywrócenie danych fabrycznych i usunięcie wszystkich swoich danych."\n\n"Szyfrowanie może potrwać godzinę lub dłużej. Rozpocznij, gdy bateria jest w pełni naładowana i nie odłączaj telefonu od zasilania do chwili ukończenia szyfrowania. Jeśli proces zostanie przerwany, utracisz część lub nawet wszystkie swoje dane."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Zaszyfruj tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Zaszyfruj telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Naładuj baterię i spróbuj ponownie."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Podłącz ładowarkę i spróbuj ponownie."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Brak kodu PIN lub hasła blokowania ekranu"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Przed rozpoczęciem szyfrowania musisz ustawić kod PIN lub hasło blokady ekranu."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Zaszyfrować?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Operacja szyfrowania jest nieodwracalna, a jej przerwanie grozi utratą danych. Szyfrowanie trwa co najmniej godzinę, a tablet zostanie w tym czasie kilkakrotnie uruchomiony ponownie."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="5682944380460921880">"Operacja szyfrowania jest nieodwracalna, a jej przerwanie grozi utratą danych. Szyfrowanie trwa co najmniej godzinę, a telefon zostanie w tym czasie kilkakrotnie uruchomiony ponownie."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Szyfrowanie"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Czekaj, trwa szyfrowanie tabletu. Ukończono: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Czekaj, trwa szyfrowanie telefonu. Ukończono: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_cooldown" msgid="685210918307862395">"Spróbuj ponownie za <xliff:g id="DELAY">^1</xliff:g> s."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Wpisz swoje hasło."</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Szyfrowanie zakończone niepowodzeniem"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Szyfrowanie zostało przerwane i nie można go dokończyć. Z tego powodu dane znajdujące się w tablecie nie są już dostępne. "\n\n"Aby dalej używać tabletu, musisz przywrócić dane fabryczne. Podczas konfigurowania po zresetowaniu będziesz mieć możliwość przywrócenia wszelkich danych, których kopia zapasowa została utworzona na koncie Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3083477162766772532">"Szyfrowanie zostało przerwane i nie można go dokończyć. Z tego powodu dane znajdujące się w telefonie nie są już dostępne. "\n\n"Aby dalej używać telefonu, musisz przywrócić dane fabryczne. Podczas konfigurowania po zresetowaniu będziesz mieć możliwość przywrócenia wszelkich danych, których kopia zapasowa została utworzona na koncie Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Przełącz metodę wprowadzania"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Wybierz blokadę ekranu"</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Wybierz blokadę zapasową"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Blokada ekranu"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Zmień blokadę ekranu"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Zmień lub wyłącz zabezpieczenie ekranu (wzór, PIN lub hasło)"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Wybierz sposób blokowania ekranu"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Wybierz sposób odblokowania w przypadku, gdy Face Unlock Cię nie rozpozna."</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Brak"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="2871898266296656162">"Przesunięcie palcem"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Bez zabezpieczeń"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Face Unlock"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Niski poziom zabezpieczeń, eksperymentalny"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Wzór"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Średni poziom zabezpieczeń"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"Kod PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Średni i wysoki poziom zabezpieczeń"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Hasło"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Wysoki poziom zabezpieczeń"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Wyłączone przez administratora lub ze względu na zasady szyfrowania albo magazyn danych logowania"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Brak"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5660014471997663139">"Przesunięcie palcem"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Face Unlock"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Wzór"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"Kod PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Hasło"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Wyłącz blokadę ekranu"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Usuń wzór odblokowania"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Usuń kod PIN odblokowania"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Usuń hasło odblokowania"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Zmień wzór odblokowania"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Zmień kod PIN odblokowania"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Zmień hasło odblokowania"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Liczba znaków w haśle musi wynosić co najmniej %d"</string>
    <string name="lockpassword_pin_too_short" msgid="2252847623267704683">"PIN musi mieć co najmniej %d znaki"</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Gdy skończysz, wybierz Kontynuuj"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Kontynuuj"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Hasło musi mieć mniej znaków niż <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"Kod PIN musi mieć mniej cyfr niż <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"Kod PIN musi zawierać wyłącznie cyfry 0-9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"Administrator urządzenia nie zezwala na ustawianie niedawno używanego kodu PIN."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Hasło zawiera niedozwolony znak."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Hasło musi zawierać co najmniej jedną literę."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Hasło musi zawierać co najmniej jedną cyfrę."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Hasło musi zawierać co najmniej jeden symbol."</string>
  <plurals name="lockpassword_password_requires_letters">
    <item quantity="one" msgid="3063853802158131458">"Hasło musi zawierać co najmniej jedną literę."</item>
    <item quantity="other" msgid="8186027808415585970">"Hasło musi zawierać litery (co najmniej %d)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Hasło musi zawierać co najmniej jedną małą literę."</item>
    <item quantity="other" msgid="2693910942679679225">"Hasło musi zawierać małe litery (co najmniej %d)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Hasło musi zawierać co najmniej jedną wielką literę."</item>
    <item quantity="other" msgid="3030801209112209245">"Hasło musi zawierać wielkie litery (co najmniej %d)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Hasło musi zawierać co najmniej jedną cyfrę."</item>
    <item quantity="other" msgid="4703982391407595924">"Hasło musi zawierać cyfry (co najmniej %d)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Hasło musi zawierać co najmniej jeden symbol specjalny."</item>
    <item quantity="other" msgid="1221290525051187757">"Hasło musi zawierać symbole specjalne (co najmniej %d)."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Hasło musi zawierać co najmniej jeden znak niebędący literą."</item>
    <item quantity="other" msgid="3952508584649046404">"Hasło musi zawierać znaki inne niż litery (co najmniej %d)."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Administrator urządzenia nie zezwala na ustawianie niedawno używanego hasła."</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"OK"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Anuluj"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Anuluj"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Dalej"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Konfiguracja została ukończona."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Administracja urządzeniem"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Administratorzy urządzenia"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Wyświetl lub dezaktywuj administratorów urządzenia"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Włącz Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Zarządzaj połączeniami, ustaw nazwę urządzenia i możliwość wykrycia"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Prośba o utworzenie powiązania Bluetooth"</string>
    <string name="bluetooth_enter_pin_msg" msgid="5698297871117529185">"Aby sparować z urządzeniem <xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>, wpisz wymagany kod PIN urządzenia:"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="2220143735340367939">"Aby sparować z urządzeniem <xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>, wpisz wymagany klucz urządzenia:"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Kod PIN zawiera litery lub symbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Zazwyczaj 0000 lub 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Może być również konieczne wpisanie tego kodu PIN na drugim urządzeniu."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Może być również konieczne wpisanie tego klucza na drugim urządzeniu."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Aby sparować z urządzeniem:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Upewnij się, że jest na nim wyświetlony następujący klucz:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Od:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Sparować z tym urządzeniem?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Aby sparować z urządzeniem <xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>, wpisz na nim klucz <xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, a następnie naciśnij klawisz zatwierdzania."</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Powiąż"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Anuluj"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Nie można sparować z urządzeniem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Nie można sparować z urządzeniem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ze względu na błędny kod PIN lub klucz."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Nie można skomunikować się z urządzeniem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Powiązanie odrzucone przez urządzenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Nie udało się nawiązać połączenia z <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Wyszukaj urządzenia"</string>
    <string name="bluetooth_search_for_devices" msgid="5957007154213560390">"Szukaj urządzeń"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Wyszukiwanie…"</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Ustawienia urządzenia"</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Powiązane urządzenia"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Dostępne urządzenia"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Połącz"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Rozłącz"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Sparuj i połącz"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Rozłącz parę"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Rozłącz i anuluj parowanie"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Opcje…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Zaawansowane"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Bluetooth – zaawansowane"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="4793562956642282639">"Aby zobaczyć urządzenia, włącz moduł Bluetooth."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Połącz z siecią…"</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Dźwięk multimediów"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Dźwięk telefonu"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Przesyłanie pliku"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Urządzenie wejściowe"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Dostęp do internetu"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Udostępnianie połączenia internetowego"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Urządzenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> zostanie odłączone od funkcji audio multimediów."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Urządzenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> zostanie odłączone od zestawu głośnomówiącego."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> zostanie odłączony od urządzenia wejściowego."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Połączenie internetowe przez urządzenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> zostanie zakończone."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="5455448395850929200">"Urządzenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> nie będzie korzystać z połączenia internetowego tego tabletu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5266851881175033601">"Urządzenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> nie będzie korzystać z połączenia internetowego tego telefonu."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Sparowane urządzenie Bluetooth"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Połącz"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Połącz z urządzeniem Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="3764437426089639639">"Profile"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Zmień nazwę"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Zezwalaj na odbieranie plików"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"Połączono z funkcją audio multimediów"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Połączono z funkcją audio telefonu"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Połączono z serwerem transferu plików"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Brak połączenia z serwerem transferu plików"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Podłączono do urządzenia wejściowego"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Połączone w celu dostępu do internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Udostępnianie połączenia internetowego"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Użyj dla funkcji audio multimediów"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Użyj dla funkcji audio telefonu"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Użyj do transferu plików"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Użyj do wprowadzania"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Użyj na potrzeby dostępu do internetu"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Ustawienia podstawki"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Używaj podstawki na potrzeby dźwięku"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Jako telefon w trybie głośnika"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Dla muzyki i multimediów"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapamiętaj ustawienia"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"Komunikacja NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Zezwalaj na wymianę danych, gdy tablet dotyka innego urządzenia"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Zezwalaj na wymianę danych, gdy telefon dotyka innego urządzenia."</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Gotowy do przesyłania treści aplikacji przez NFC"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Wyłączona"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Niedostępne przy wyłączonym NFC"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Po włączeniu tej funkcji możesz przesyłać dane między urządzeniami z funkcją NFC, zbliżając oba aparaty do siebie. Możliwe jest na przykład przesłanie stron z przeglądarki, filmów z YouTube, kontaktów z telefonu itp."\n\n"Wystarczy zetknąć urządzenia ze sobą i dotknąć ekranu. Aplikacja automatycznie określi, jakie dane chcesz przesłać."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Wykrywanie usług sieciowych"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Zezwól aplikacjom z innych urządzeń wykrywać aplikacje na tym urządzeniu"</string>
    <string name="wifi_quick_toggle_title" msgid="874495178395350104">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="1047950931623694366">"Włącz Wi-Fi"</string>
    <string name="wifi_settings" msgid="1277428034634973011">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="2810363951104753710">"Ustawienia Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="4351120897298124250">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Konfiguruj punkty dostępowe sieci bezprzewodowej i zarządzaj nimi"</string>
    <string name="wifi_setup_wizard_title" msgid="70277346338812325">"Wybierz Wi-Fi"</string>
    <string name="wifi_starting" msgid="6716593470710880000">"Włączanie Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="244864762599017659">"Wyłączanie Wi-Fi..."</string>
    <string name="wifi_error" msgid="3207971103917128179">"Błąd"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"W trybie samolotowym"</string>
    <string name="wifi_fail_to_scan" msgid="1265540342578081461">"Nie można wyszukać sieci."</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Powiadomienie o sieci"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3038290727701553612">"Powiadom mnie, gdy będę w zasięgu otwartej sieci"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Unikaj słabych połączeń"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2466956369738047669">"Nie łącz z Wi-Fi, jeśli połączenie jest słabe"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="9107237003911220057">"Wi-Fi w trybie uśpienia"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Wystąpił problem ze zmianą ustawienia"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Dodaj sieć"</string>
    <string name="wifi_access_points" msgid="2664629396767022441">"Sieci Wi-Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Przycisk WPS"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Kod PIN dla WPS"</string>
    <string name="wifi_menu_p2p" msgid="2575893749303670353">"Wi-Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Skanuj"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Zaawansowane"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Połącz z siecią"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Zapomnij sieć"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modyfikuj sieć"</string>
    <string name="wifi_empty_list_wifi_off" msgid="4722299515264875943">"Aby zobaczyć dostępne sieci, włącz obsługę Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="3354911729026237372">"Wyszukuję sieci Wi-Fi…"</string>
    <string name="wifi_other_network" msgid="1048006316504242214">"Inna sieć…"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Więcej"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Autokonfiguracja (WPS)"</string>
    <string name="wifi_show_advanced" msgid="1793703023711426246">"Opcje zaawansowane"</string>
    <string name="wifi_wps_setup_title" msgid="6034518116333042484">"Konfiguracja zabezpieczonej sieci Wi-Fi"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Uruchamianie WPS..."</string>
    <string name="wifi_wps_onstart_pbc" msgid="7204827509934892103">"Naciśnij przycisk konfiguracji zabezpieczonej sieci Wi-Fi na routerze. Może on mieć nazwę „WPS” lub ten symbol:"</string>
    <string name="wifi_wps_onstart_pin" msgid="8116564886303972764">"Wpisz <xliff:g id="NUMBER">%1$s</xliff:g> na routerze Wi-Fi. Konfiguracja może potrwać do dwóch minut."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"Konfiguracja WPS powiodła się. Łączenie z siecią..."</string>
    <string name="wifi_wps_connected" msgid="5754399645462924103">"Połączono z siecią Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="2944576520214787628">"Konfigurowanie WPS już trwa i może potrwać nawet dwie minuty"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"Konfiguracja WPS nie powiodła się. Spróbuj ponownie za kilka minut."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Ustawienie zabezpieczeń routera bezprzewodowego (WEP) nie jest obsługiwane"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Ustawienie zabezpieczeń routera bezprzewodowego (TKIP) nie jest obsługiwane"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Błąd uwierzytelniania. Spróbuj ponownie."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Wykryto inną sesję WPS. Spróbuj ponownie za kilka minut."</string>
    <string name="wifi_ssid" msgid="641393708309146745">"Identyfikator SSID sieci"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Zabezpieczenia"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Siła sygnału"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Stan"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Szybkość łącza"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Adres IP"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Metoda EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Uwierzytelnianie w drugiej fazie"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certyfikat urzędu certyfikacji"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certyfikat użytkownika"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Tożsamość"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Tożsamość anonimowa"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Hasło"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Pokaż hasło"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Ustawienia IP"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nie zmieniono)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(nie określono)"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"Zapisana"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Wyłączona"</string>
    <string name="wifi_disabled_network_failure" msgid="3111321240793227690">"Uniknięto połączenia internetowego o niskiej jakości."</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Problem z uwierzytelnianiem"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Poza zasięgiem"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"Protokół WPS jest dostępny"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (protokół WPS dostępny)"</string>
    <string name="wifi_secured_first_item" msgid="4072076186051083451">"Zabezpieczona za pomocą protokołu <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_secured_second_item" msgid="1326000076939056265">", zabezpieczona za pomocą protokołu <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Brak"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Połącz"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Nie można nawiązać połączenia z siecią"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Zapomnij"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Nie udało się zapomnieć sieci"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Zapisz"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Nie udało się zapisać sieci"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Anuluj"</string>
    <string name="wifi_advanced_titlebar" msgid="1627063574532930090">"Zaawansowane opcje Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Pasmo częstotliwości sieci Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Określ używany zakres częstotliwości"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Wystąpił problem podczas ustawiania częstotliwości."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adres MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adres IP"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Ustawienia adresu IP"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Zapisz"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Anuluj"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Wpisz prawidłowy adres IP."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Wpisz prawidłowy adres bramy."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Wpisz prawidłowy adres DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Wpisz długość przedrostka sieci z zakresu 0-32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Brama"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Długość przedrostka sieci"</string>
    <string name="wifi_p2p_settings_title" msgid="400503541488064638">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informacje o urządzeniu"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Zapamiętaj to połączenie"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Szukaj urządzeń"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Wyszukiwanie…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Zmień nazwę urządzenia"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Urządzenia Peer"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Nie udało się połączyć."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Zmiana nazwy urządzenia nie powiodła się."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Rozłączyć?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Po rozłączeniu Twoje połączenie z <xliff:g id="PEER_NAME">%1$s</xliff:g> zostanie zakończone."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Po rozłączeniu Twoje połączenie z <xliff:g id="PEER_NAME">%1$s</xliff:g> i <xliff:g id="PEER_COUNT">%2$s</xliff:g> innymi urządzeniami zostanie zakończone."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Anulować zaproszenie?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Czy chcesz anulować zaproszenie do połączenia z <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_tether_checkbox_text" msgid="6961605862058056788">"Przenośny punkt Wi-Fi"</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Przenośny punkt dostępu <xliff:g id="NETWORK_SSID">%1$s</xliff:g> jest aktywny"</string>
    <string name="wifi_tether_failed_subtext" msgid="2654888578056042315">"Błąd przenośnego punktu dostępu Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="61237027772641155">"Skonfiguruj hotspot Wi-Fi"</string>
    <string name="wifi_tether_configure_subtext" msgid="1927454307836232128">"Przenośny punkt Wi-Fi <xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g>"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"Punkt dostępu Android"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Wyświetlacz"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Dźwięk"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Dzwonek telefonu"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Głośność"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Efekty muzyczne"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Głośność dzwonka"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Wibracje po wyciszeniu"</string>
    <string name="notification_sound_title" msgid="312032901303146002">"Powiadomienie domyślne"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Pulsująca dioda"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Dzwonek"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Powiadomienie"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Użyj głośności połączeń przychodzących dla powiadomień"</string>
    <string name="notification_sound_dialog_title" msgid="9052854168612951170">"Wybierz dzwonek powiadomienia"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Multimedia"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Ustaw głośność muzyki oraz filmów wideo"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarm"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Ustawienia dźwięku dla podłączonej podstawki"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Dźwięki wybierania numeru"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Dźwięki przy dotknięciu"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Dźwięk blokady ekranu"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Wibracje przy dotknięciu"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Eliminowanie szumu"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muzyka, filmy, gry i inne multimedia"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Dzwonek i powiadomienia"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Powiadomienia"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmy"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Wycisz dzwonek i powiadomienia"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Wycisz muzykę i inne multimedia"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Wycisz powiadomienia"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Wycisz alarmy"</string>
    <string name="vibrate_when_ringing_title" msgid="3885857358303178029">"Wibracje i dzwonek"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Podstawka"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Ustawienia podstawki"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Dźwięk"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Ustawienia dla biurkowej stacji dokującej"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Ustawienia dla samochodowej stacji dokującej"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablet niezadokowany"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon niezadokowany"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Ustawienia dla podłączonej podstawki"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Nie znaleziono podstawki"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Przed skonfigurowaniem dźwięku stacji dokującej musisz zadokować tablet."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Przed skonfigurowaniem dźwięku stacji dokującej musisz zadokować telefon."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Dźwięk włożenia do stacji dokującej"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Odtwarzaj dźwięk podczas umieszczania tabletu w doku i wyjmowania go"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Odtwarzaj dźwięk podczas umieszczania telefonu w podstawce i wyjmowania go"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"Nie odtwarzaj dźwięku podczas umieszczania tabletu w doku i wyjmowania go"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"Nie odtwarzaj dźwięku podczas umieszczania telefonu w podstawce i wyjmowania go"</string>
    <string name="account_settings" msgid="6403589284618783461">"Konta"</string>
    <string name="search_settings" msgid="1910951467596035063">"Wyszukiwanie"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Zarządzaj ustawieniami i historią wyszukiwania"</string>
    <string name="display_settings" msgid="7965901687241669598">"Wyświetlacz"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Autoobracanie ekranu"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Automatycznie przełącz orientację przy obracaniu tabletu"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Automatycznie przełącz orientację przy obracaniu telefonu"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Automatycznie przełącz orientację przy obracaniu tabletu"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Automatycznie przełącz orientację przy obracaniu telefonu"</string>
    <string name="brightness" msgid="2354961343555249270">"Jasność ekranu"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Dostosuj jasność ekranu"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Uśpienie"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> bezczynności"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Tapeta"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Wybierz tapetę z..."</string>
    <string name="screensaver_settings_title" msgid="3848608373818910549">"Upiększanie ekranu"</string>
    <string name="screensaver_settings_summary_on" msgid="433728808047613634">"W trybie uśpienia, jeśli jest podłączone zasilanie."</string>
    <string name="screensaver_settings_summary_off" msgid="7019248565878953105">"Wyłączone"</string>
    <string name="screensaver_component_title" msgid="8596216100441725363">"Wybrane upiększenia"</string>
    <string name="screensaver_timeout_title" msgid="4882666970355550822">"Włączenie wygaszacza"</string>
    <string name="screensaver_timeout_summary" msgid="7717201094598701673">"Po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> bezczynności"</string>
    <string name="screensaver_timeout_zero_summary" msgid="1274235565189071582">"Nigdy"</string>
    <string name="screensaver_test" msgid="3048249263811694128">"Wypróbuj"</string>
    <string name="screensaver_activate_on_dock_title" msgid="3753003388633168862">"Także, gdy zadokowany."</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatyczna"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Rozmiar czcionki"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Rozmiar czcionki"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Ustawienia blokady karty SIM"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Ustaw blokadę SIM"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Blokada karty SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Zablokuj kartę SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Wymagaj kodu PIN w celu użycia tabletu"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Aby korzystać z telefonu, należy wprowadzić kod PIN"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Wymagaj kodu PIN w celu użycia tabletu"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Aby korzystać z telefonu, należy wprowadzić kod PIN"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Zmień PIN do karty SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"Kod PIN do karty SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zablokuj kartę SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Odblokuj kartę SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Stary kod PIN do karty SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nowy kod PIN do karty SIM"</string>
    <string name="sim_reenter_new" msgid="3178510434642201544">"Wpisz ponownie nowy kod PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Kod PIN do karty SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Błędny kod PIN"</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"Kody PIN nie są identyczne."</string>
    <string name="sim_change_failed" msgid="304964924772218382">"Nie można zmienić kodu PIN."\n"Wpisany kod PIN może być błędny."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Kod PIN do karty SIM został pomyślnie zmieniony"</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"Nie można zmienić stanu blokady karty SIM."\n"Wpisany kod PIN może być błędny."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Anuluj"</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Stan tabletu"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Stan telefonu"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Aktualizacje systemowe"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Wersja systemu Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Numer modelu"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"Identyfikator sprzętu"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Wersja pasma podstawowego"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Wersja jądra"</string>
    <string name="build_number" msgid="3075795840572241758">"Numer kompilacji"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Niedostępna"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Informacje o telefonie"</string>
    <string name="device_status" msgid="607405385799807324">"Informacje o telefonie"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Stan baterii, sieci i inne informacje"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Numer telefonu, sygnał itd."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Pamięć"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Ustawienia pamięci"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Odłącz nośnik USB i wyświetl ilość dostępnej pamięci"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Odłącz kartę SD, pokaż ilość dostępnej pamięci w telefonie"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Mój numer telefonu"</string>
    <string name="status_min_number" msgid="3519504522179420597">"Numer MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Wersja PRL"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"Numer MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="3279383550222116235">"Typ sieci komórkowej"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Stan sieci komórkowej"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stan usługi"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Siła sygnału"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Sieć"</string>
    <string name="status_wifi_mac_address" msgid="33109409206264790">"Adres MAC karty Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adres Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Numer seryjny"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Niedostępny"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Czas działania"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Czas działania (włączony)"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Pamięć wewnętrzna"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Nośnik USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Karta SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"Wolne"</string>
    <string name="memory_size" msgid="6629067715017232195">"Całkowita pojemność"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Obliczanie..."</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Aplikacje (dane aplikacji i multimedia)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Multimedia"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Pobrane"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Zdjęcia, filmy"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Dźwięk (muzyka, dzwonki, podcasty itp.)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Różne"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Odłącz pamięć współdzieloną"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Odłącz kartę SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Odłącz wewnętrzny nośnik USB"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Odłącz kartę SD, aby bezpiecznie ją wyjąć"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Włóż USB do podłączenia"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Włóż kartę SD w celu zainstalowania"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Podłącz nośnik USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Zainstaluj kartę SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Wyczyść nośnik USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Wyczyść kartę SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Wymazuje wszystkie dane z wewnętrznego nośnika USB, np. pliki muzyczne i zdjęcia"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Wymazuje z karty SD telefonu wszystkie dane, takie jak muzyka czy zdjęcia"</string>
    <string name="read_only" msgid="6702420168629076340">" (Tylko do odczytu)"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Odłączyć nośnik USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Odłączyć kartę SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Jeśli odłączysz nośnik USB, niektóre używane aplikacje zostaną zatrzymane i mogą być niedostępne do chwili jego ponownego podłączenia."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Jeśli odłączysz kartę SD, niektóre używane aplikacje zostaną zatrzymane i mogą być niedostępne do chwili jej ponownego podłączenia."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="4346280469528260684">"Nie można odłączyć nośnika USB. Spróbuj ponownie później."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"Nie można odłączyć karty SD. Spróbuj ponownie później."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Nośnik USB zostanie odłączony."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Karta SD zostanie odłączona."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Odinstalowywanie"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Odinstalowywanie w toku"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Kończy się miejsce"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Niektóre funkcje systemu (np. synchronizacja) mogą nie działać poprawnie. Zwolnij miejsce, usuwając lub odpinając takie elementy jak aplikacje i multimedia."</string>
    <string name="storage_menu_usb" msgid="5708207885333243384">"Połączenie USB z komputerem"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Połączenie USB z komputerem"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Połącz jako"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Urządzenie multimedialne (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Umożliwia przesyłanie plików multimedialnych w Windows lub przy użyciu aplikacji Android File Transfer (dostępny na www.android.com/filetransfer) dla Mac OS X."</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Aparat (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"Umożliwia przesyłanie zdjęć za pomocą oprogramowania aparatu, a także przesyłanie dowolnych plików na komputerach, które nie obsługują urządzeń MTP."</string>
    <string name="usb_label_installer_cd" msgid="4331173824920630215">"Instaluj narzędzia do transferu plików"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Stan baterii"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Poziom naładowania baterii"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Nazwy APN"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Edytuj punkt dostępowy"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nie ustawiono"</string>
    <string name="apn_name" msgid="4115580098369824123">"Nazwa"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Nazwa użytkownika"</string>
    <string name="apn_password" msgid="5412301994998250968">"Hasło"</string>
    <string name="apn_server" msgid="2436185314756372858">"Serwer"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Proxy dla MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Port MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Typ uwierzytelniania"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Brak"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP lub CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Typ APN"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokół APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokół APN podczas roamingu"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Włącz/wyłącz APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN włączona"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN wyłączona"</string>
    <string name="bearer" msgid="594270280031923558">"Nośnik"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Usuń APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nowy APN"</string>
    <string name="menu_save" msgid="8109345640668285399">"Zapisz"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Odrzuć"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Nazwa nie może być pusta."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"Nazwa APN nie może być pusta."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Pole MMC musi zawierać 3 cyfry."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Pole MNC musi zawierać 2 lub 3 cyfry."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Przywracanie domyślnych ustawień APN"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Resetuj ustawienia"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Przywracanie domyślnych ustawień APN zostało ukończone."</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Ustawienia fabryczne"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Wymazuje wszystkie dane z tabletu"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Wymazuje wszystkie dane w telefonie"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"Zostaną usunięte wszystkie dane z "<b>"wewnętrznej pamięci"</b>" tabletu, w tym:"\n\n<li>"Dane konta Google"</li>\n<li>"Dane i ustawienia systemu oraz aplikacji"</li>\n<li>"Pobrane aplikacje"</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"Zostaną usunięte wszystkie dane z "<b>"wewnętrznej pamięci"</b>" telefonu, w tym:"\n\n<li>"Dane konta Google"</li>\n<li>"Dane i ustawienia systemu oraz aplikacji"</li>\n<li>"Pobrane aplikacje"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Zalogowano się na konta:"\n</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Muzyka"</li>\n<li>"Zdjęcia"</li>\n<li>"Inne dane użytkownika"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Aby usunąć muzykę, zdjęcia i inne dane użytkownika, należy wymazać "<b>"nośnik USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Aby usunąć muzykę, zdjęcia i inne dane użytkownika, należy wymazać "<b>"kartę SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Wyczyść nośnik USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Wyczyść kartę SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Wymaż wszystkie dane z wewnętrznego nośnika USB, np. pliki muzyczne i zdjęcia."</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Wymaż wszystkie dane z karty SD, np. pliki muzyczne i zdjęcia."</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Resetuj tablet"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Resetuj telefon"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Wymazać wszystkie Twoje informacje osobiste i pobrane aplikacje? Tej czynności nie można cofnąć."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Wymaż wszystko"</string>
    <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Narysuj wzór odblokowania"</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Aby potwierdzić przywrócenie danych fabrycznych, musisz narysować wzór odblokowania."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Nie wykonano resetowania, ponieważ usługa czyszczenia systemu jest niedostępna."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Zresetować?"</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Wyczyść nośnik USB"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Wyczyść kartę SD"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Wymazuje wszystko z nośnika USB"</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Wymazuje wszystkie dane z karty SD"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Wymazać cały nośnik USB? Utracisz "<b>"wszystkie"</b>" zapisane dane."</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Wymazać kartę SD? Utracisz "<b>"wszystkie"</b>" zapisane na niej dane."</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Wyczyść nośnik USB"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Wyczyść kartę SD"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Wymazać nośnik USB, usuwając wszystkie zapisane na nim pliki? Tej czynności nie można cofnąć."</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Wymazać kartę SD, usuwając wszystkie zapisane na niej pliki? Tej czynności nie można cofnąć."</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Wymaż wszystko"</string>
    <string name="media_format_gesture_prompt" msgid="3109349468816856670">"Narysuj wzór odblokowania"</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"Aby potwierdzić zamiar wyczyszczenia nośnika USB, musisz narysować wzór odblokowania."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"Aby potwierdzić zamiar wyczyszczenia karty SD, musisz narysować wzór odblokowania."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Ustawienia połączeń"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Poczta głosowa, przekazywanie połączeń, poł. oczekujące, ID rozmówcy"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Tethering przez USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Przenośny punkt dostępu"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Tethering przez Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Tethering"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Tethering i punkt dostępu"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Tethering przez USB"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"Podłączono USB – zaznacz, aby powiązać"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Powiązano"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Nie można powiązać, gdy używany jest nośnik USB."</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"Nie podłączono USB"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Błąd tetheringu przez USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Tethering przez Bluetooth"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Udostępnianie połączenia internetowego w tablecie"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Udostępnianie połączenia internetowego w telefonie"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Udostępnianie połączenia internetowego jednemu urządzeniu"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Udostępnianie połączenia internetowego jednemu urządzeniu"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Udostępnianie połączenia internetowego urządzeniom: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Udostępnianie połączenia internetowego urządzeniom: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Połączenie internetowe nie jest udostępniane"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Połączenie internetowe nie jest udostępniane"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Brak powiązania"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"Nie można powiązać więcej niż <xliff:g id="MAXCONNECTION">%1$d</xliff:g> urządzeń."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Powiązanie z urządzeniem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> zostanie anulowane."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Pomoc"</string>
    <string name="network_settings_title" msgid="7967552516440151852">"Sieci komórkowe"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja lokalizacja"</string>
    <string name="location_network_based" msgid="5569673665032992664">"Usługa lokalizacyjna"</string>
    <string name="location_neighborhood_level" msgid="2948129720516513300">"Zezwalaj na przesyłanie do Google anonimowych danych o lokalizacji. Zezwalaj uprawnionym aplikacjom na określanie przybliżonej lokalizacji z użyciem sieci komórkowych i Wi-Fi."</string>
    <string name="location_neighborhood_level_wifi" msgid="7457348712272184793">"Lokalizacja określona na podstawie sieci Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satelity GPS"</string>
    <string name="location_street_level" msgid="4244496898967415234">"Zezwalaj aplikacjom na określanie mojej lokalizacji za pomocą GPS"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Użyj wspomaganego systemu GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Użyj serwera do wspomagania systemu GPS (usuń zaznaczenie, aby zmniejszyć ruch sieciowy)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Użyj serwera do wspomagania systemu GPS (usuń zaznaczenie, aby zwiększyć wydajność systemu GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Lokalizacja w sieci"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Zezwalaj Google na użycie danych o mojej lokalizacji, aby poprawić wyszukiwanie i inne usługi"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Informacje o tablecie"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Informacje o telefonie"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Wyświetl informacje prawne, stan, wersję oprogramowania"</string>
    <string name="legal_information" msgid="5769301644270604095">"Informacje prawne"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Współautorzy"</string>
    <string name="copyright_title" msgid="865906688917260647">"Prawa autorskie"</string>
    <string name="license_title" msgid="1990487604356037871">"Licencja"</string>
    <string name="terms_title" msgid="7697580845616764642">"Warunki i zasady korzystania"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Licencje open source"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Wystąpił problem podczas ładowania licencji."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Ładowanie..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informacje o bezpieczeństwie"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informacje o bezpieczeństwie"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Brak połączenia transmisji danych. Aby wyświetlić te informacje teraz, przejdź do strony %s na dowolnym komputerze połączonym z internetem."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Trwa wczytywanie..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Wybierz hasło"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Wybierz wzór"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Wybierz kod PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Potwierdź hasło"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potwierdź wzór"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Potwierdź kod PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Hasła nie są identyczne"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"Kody PIN nie są identyczne"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Wybór blokady"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Hasło zostało ustawione"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Kod PIN został ustawiony"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Wzór został ustawiony"</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Zabezpieczenie ekranu"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Zmień wzór odblokowania"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Zmień kod PIN odblokowania"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Potwierdź zapisany wzór"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Spróbuj ponownie:"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Narysuj wzór odblokowania"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Naciśnij Menu, aby uzyskać pomoc."</string>
    <string name="lockpattern_recording_inprogress" msgid="4622772178078818425">"Puść palec, gdy gotowe."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3103250430366718996">"Połącz co najmniej <xliff:g id="NUMBER">%d</xliff:g> kropki. Spróbuj jeszcze raz:"</string>
    <string name="lockpattern_pattern_entered_header" msgid="8378617839439987962">"Wzór został nagrany."</string>
    <string name="lockpattern_need_to_confirm" msgid="5144676887162575050">"Narysuj wzór ponownie, aby potwierdzić:"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2223856038485537716">"Nowy wzór odblokowania:"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potwierdź"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Narysuj ponownie"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Ponów próbę"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Dalej"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Wzór odblokowania"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Wymagaj wzoru"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Trzeba narysować wzór, aby odblokować ekran"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Wzór jest widoczny"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Wibracje przy dotknięciu"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Blokada przyciskiem zasilania"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Ustaw wzór odblokowania"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Zmień wzór odblokowania"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Jak narysować wzór odblokowania"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Zbyt wiele nieudanych prób!"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Spróbuj ponownie za <xliff:g id="NUMBER">%d</xliff:g> sekund."</string>
    <string name="skip_button_label" msgid="8680422740354436943">"Anuluj"</string>
    <string name="next_button_label" msgid="8890792540116568321">"Dalej"</string>
    <string name="lock_title" product="tablet" msgid="2909697418179419990">"Zabezpieczanie tabletu"</string>
    <string name="lock_title" product="default" msgid="4059246467204273930">"Zabezpieczanie telefonu"</string>
    <string name="lock_intro_message" product="tablet" msgid="8616353869251700776">"Chroń swój tablet przed nieautoryzowanym użyciem, tworząc osobisty wzór odblokowania ekranu. Na następnym ekranie połącz palcem co najmniej cztery kropki w dowolnej kolejności. "\n\n"Wszystko gotowe? Wybierz Dalej."</string>
    <string name="lock_intro_message" product="default" msgid="8393155371327584659">"Chroń swój telefon przed nieautoryzowanym użyciem, tworząc osobisty wzór odblokowania ekranu. Na następnym ekranie połącz palcem co najmniej cztery kropki w dowolnej kolejności. "\n\n"Wszystko gotowe? Wybierz Dalej."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Zarządzaj aplikacjami"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Zarządzaj zainstalowanymi aplikacjami i usuwaj je."</string>
    <string name="applications_settings" msgid="1721442176406964682">"Aplikacje"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Zarządzaj aplikacjami, konfiguruj skróty szybkiego uruchamiania."</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Ustawienia aplikacji"</string>
    <string name="install_applications" msgid="4872012136210802181">"Nieznane źródła"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Zezwalaj na instalowanie aplikacji z nieznanych źródeł"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Twój tablet i dane osobiste są bardziej narażone na ataki aplikacji z nieznanych źródeł. Akceptujesz fakt, że ponosisz wyłączną odpowiedzialność za wszelkie możliwe szkody w tablecie i utratę danych w wyniku korzystania z tych aplikacji."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Twój telefon i dane osobiste są bardziej narażone na ataki aplikacji z nieznanych źródeł. Akceptujesz fakt, że ponosisz wyłączną odpowiedzialność za wszelkie możliwe szkody w telefonie i utratę danych w wyniku korzystania z tych aplikacji."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Ustawienia zaawansowane"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Włącz więcej opcji ustawień."</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informacje o aplikacji"</string>
    <string name="storage_label" msgid="8700867073480107253">"Pamięć"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Uruchom domyślnie"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Domyślne"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Zgodność z ekranem"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Uprawnienia"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Pamięć podręczna"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Wyczyść pamięć podręczną"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Pamięć podręczna"</string>
    <string name="controls_label" msgid="7611113077086853799">"Elementy sterujące"</string>
    <string name="force_stop" msgid="7435006169872876756">"Wymuś zatrzymanie"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Razem"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Aplikacja"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikacja w pamięci USB"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Dane"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Dane w pamięci USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Karta SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Odinstaluj"</string>
    <string name="disable_text" msgid="6544054052049395202">"Dezaktywuj"</string>
    <string name="enable_text" msgid="9217362512327828987">"Włącz"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Wyczyść dane"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Odinstaluj aktualizacje"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Aplikacja jest domyślnie uruchamiana w przypadku niektórych działań."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Zdecydowałeś, że ta aplikacja może tworzyć widgety i mieć dostęp do ich danych."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Brak ustawień domyślnych."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Wyczyść domyślne"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Aplikacja może nie być przystosowana do ekranu Twojego urządzenia. Tutaj możesz ją skonfigurować do obsługi ekranu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Zapytaj po uruchomieniu"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Skaluj aplikację"</string>
    <string name="unknown" msgid="1592123443519355854">"Nieznana"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Sortuj według nazwy"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Sortuj według rozmiaru"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Pokaż działające usługi"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Pokaż procesy z pamięci podręcznej"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Resetuj opcje aplikacji"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Zresetować opcje aplikacji?"</string>
    <string name="reset_app_preferences_desc" msgid="1118129530999596317">"Wszystkie te ustawienia zostaną zresetowane:"\n\n" "<li>"wyłączone aplikacje,"</li>\n" "<li>"wyłączone powiadomienia aplikacji,"</li>\n" "<li>"aplikacje używane domyślnie do wykonania czynności,"</li>\n" "<li>"ograniczenia użycia danych w tle w aplikacjach."</li>\n\n" Nie utracisz żadnych danych aplikacji."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Resetuj aplikacje"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Zarządzaj rozmiarem"</string>
    <string name="filter" msgid="2018011724373033887">"Filtr"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Wybierz opcje filtru"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Wszystkie"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Pobrane"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Pracują"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Nośnik USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na karcie SD"</string>
    <string name="disabled" msgid="9206776641295849915">"Wyłączone"</string>
    <string name="no_applications" msgid="7336588977497084921">"Brak aplikacji"</string>
    <string name="internal_storage" msgid="1584700623164275282">"Pamięć wewnętrzna"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Nośnik USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Pamięć karty SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Przeliczanie rozmiaru..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Usunąć dane aplikacji?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Wszystkie dane tej aplikacji zostaną trwale usunięte. Dotyczy to wszystkich plików, ustawień, kont, baz danych itd."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Anuluj"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"Aplikacji nie znaleziono na liście zainstalowanych aplikacji."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Nie można wyczyścić danych aplikacji."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Odinstalować aktualizacje?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Wszystkie aktualizacje tej aplikacji systemowej Androida zostaną odinstalowane."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Wyczyść dane"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Nie można wyczyścić danych aplikacji."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Aplikacja ma dostęp do następujących elementów na tablecie:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Aplikacja ma dostęp do następujących elementów na telefonie:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Aplikacja ma dostęp do tych elementów na tablecie. Aby poprawić wydajność i zmniejszyć użycie pamięci, aplikacja <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> ma niektóre z tych uprawnień, bo działa wewnątrz tego samego procesu co <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Aplikacja ma dostęp do tych elementów na telefonie. Aby poprawić wydajność i zmniejszyć użycie pamięci, aplikacja <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> ma niektóre z tych uprawnień, bo działa wewnątrz tego samego procesu co <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> i <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> i <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="1599186977475211186">"Przetwarzanie..."</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Nie udało się obliczyć rozmiaru pakietu."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Nie masz zainstalowanych żadnych aplikacji firm zewnętrznych."</string>
    <string name="version_text" msgid="9189073826278676425">"wersja <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Przenieś"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Przenieś do tabletu"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Przenieś do telefonu"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Przenieś na nośnik USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Przenieś na kartę SD"</string>
    <string name="moving" msgid="6431016143218876491">"Przenoszenie"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Za mało miejsca w pamięci."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"Aplikacja nie istnieje."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplikacja jest zabezpieczona przed kopiowaniem."</string>
    <string name="invalid_location" msgid="2786030127356312746">"Lokalizacja instalacji jest nieprawidłowa."</string>
    <string name="system_package" msgid="6222593098063037137">"Aktualizacji systemu nie można instalować na nośniku zewnętrznym."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Wymusić zatrzymanie?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Jeśli wymusisz zatrzymanie aplikacji, może ona zadziałać nieprawidłowo."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Nie można przenieść aplikacji. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Preferowana lokalizacja instalacji"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Zmień preferowaną lokalizację instalacji nowych aplikacji."</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Wyłączyć wbudowaną aplikację?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Jeśli wyłączysz wbudowaną aplikację, inne aplikacje mogą działać nieprawidłowo."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Wyłączyć powiadomienia?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Jeśli wyłączysz powiadomienia tej aplikacji, możesz przeoczyć ważne alerty i aktualizacje."</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Użycie pamięci"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Wyświetl pamięć używaną przez aplikacje"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Uruchomione usługi"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Wyświetl i kontroluj obecnie uruchomione usługi"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Ponowne uruchamianie"</string>
    <string name="cached" msgid="1059590879740175019">"Proces w tle z pamięci podręcznej"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Brak uruchomionych usług."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Uruchomiona przez aplikację"</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> wolne"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> w użyciu"</string>
    <string name="memory" msgid="6609961111091483458">"Pamięć RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces, <xliff:g id="NUMSERVICES">%2$d</xliff:g> usługa"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces, <xliff:g id="NUMSERVICES">%2$d</xliff:g> usługi"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesy, <xliff:g id="NUMSERVICES">%2$d</xliff:g> usługa"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesy, <xliff:g id="NUMSERVICES">%2$d</xliff:g> usługi"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Uruchomiona aplikacja"</string>
    <string name="no_services" msgid="7133900764462288263">"Nieaktywne"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Usługi"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesy"</string>
    <string name="service_stop" msgid="6369807553277527248">"Zatrzymaj"</string>
    <string name="service_manage" msgid="1876642087421959194">"Ustawienia"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Usługa została uruchomiona przez odpowiednią aplikację. Jej zatrzymanie może spowodować awarię tej aplikacji."</string>
    <string name="heavy_weight_stop_description" msgid="2979218727598321095">"Nie można bezpiecznie zatrzymać tej aplikacji. Może to spowodować utratę części Twojej bieżącej pracy."</string>
    <string name="background_process_stop_description" msgid="5034773197139654588">"Jest to stary proces aplikacji uruchomiony na wypadek, gdyby był jeszcze potrzebny. Zwykle nie ma powodu, aby go zatrzymywać."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: aktualnie w użyciu. Dotknij opcji Ustawienia, aby nią sterować."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Główny proces w użyciu"</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Usługa <xliff:g id="COMP_NAME">%1$s</xliff:g> jest w użyciu."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Dostawca <xliff:g id="COMP_NAME">%1$s</xliff:g> jest w użyciu."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Czy zatrzymać usługę systemową?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Jeśli zatrzymasz tę usługę, niektóre funkcje tabletu mogą przestać poprawnie działać do chwili jego wyłączenia i ponownego włączenia."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Jeśli zatrzymasz tę usługę, niektóre funkcje telefonu mogą przestać poprawnie działać do chwili jego wyłączenia i ponownego włączenia."</string>
    <string name="language_settings" msgid="5292716747264442359">"Język, klawiatura, głos"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Język, klawiatura, głos"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Ustawienia języka"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Klawiatura i wprowadzanie tekstu"</string>
    <string name="phone_language" msgid="8870144109924299673">"Język"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Autokorekta"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Poprawiaj błędnie wpisane słowa"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Wstawiaj wielkie litery"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Zaczynaj zdania wielką literą"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Łatwa interpunkcja"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Ustawienia klawiatury fizycznej"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Naciśnij dwukrotnie klawisz spacji, aby wstawić kropkę"</string>
    <string name="show_password" msgid="3001113966880559611">"Hasła są widoczne"</string>
    <string name="show_password_summary" msgid="7345931695292850058"></string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Ta metoda wprowadzania może gromadzić cały wpisywany tekst, w tym dane osobiste w postaci haseł i numerów kart kredytowych. Pochodzi ona z aplikacji <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Użyć jej?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ten moduł sprawdzania pisowni może gromadzić cały wpisywany tekst, w tym dane osobiste w postaci haseł i numerów kart kredytowych. Pochodzi on z aplikacji <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Użyć go?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Ustawienia"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Język"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Nie udało się otworzyć ustawień aplikacji <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g>"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Mysz/touchpad"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Szybkość wskaźnika"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Kontroler gier"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Użyj wibracji"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Po podłączeniu kontrolera gier przekieruj do niego wibracje."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Wybierz układ klawiatury"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Skonfiguruj układy klawiatury"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Control-spacja, by przełączyć"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Domyślna"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Układy klawiatury"</string>
    <string name="user_dict_settings_titlebar" msgid="765659257455000490">"Słownik użytkownika"</string>
    <string name="user_dict_single_settings_title" msgid="524997218433540614">"Słownik osobisty"</string>
    <string name="user_dict_multiple_settings_title" msgid="3735224433307996276">"Osobiste słowniki"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Dodaj do słownika"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Wyrażenie"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Więcej opcji"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Mniej opcji"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Słowo:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Skrót:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Język:"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Edytuj słowo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Edytuj"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Usuń"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"Nie masz żadnych słów w słowniku użytkownika. Aby dodać słowo, wybierz Dodaj (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Dla wszystkich języków"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Więcej języków..."</string>
    <string name="testing" msgid="6584352735303604146">"Testowanie"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informacje o tablecie"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informacje o telefonie"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Informacje o baterii"</string>
    <string name="quick_launch_title" msgid="7904609846945905306">"Szybkie uruchamianie"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Ustaw skróty klawiaturowe, aby uruchamiać aplikacje."</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Przypisz aplikację"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Brak skrótu"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Szukaj + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Wyczyść"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Skrót do <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) zostanie usunięty."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"OK"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Anuluj"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Aplikacje"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Skróty"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Wprowadzanie tekstu"</string>
    <string name="input_method" msgid="5434026103176856164">"Sposób wprowadzania tekstu"</string>
    <string name="current_input_method" msgid="234072873286056438">"Domyślna"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Wybór sposobu wprowadzania tekstu"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatyczny"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Zawsze pokazuj"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Zawsze ukrywaj"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Konfiguruj metody wprowadzania"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Ustawienia"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Ustawienia"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktywne metody wprowadzania"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Użyj języka systemu"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Ustawienia <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Wybierz aktywne metody wprowadzania"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Ustawienia klawiatury ekranowej"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Klawiatura fizyczna"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Ustawienia klawiatury fizycznej"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Opcje programistyczne"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Ustaw opcje związane z programowaniem aplikacji."</string>
    <string name="enable_adb" msgid="7982306934419797485">"Debugowanie USB"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Tryb debugowania, gdy podłączone jest USB"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Zostaw włączony"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Ekran nie będzie gaszony podczas ładowania telefonu"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Pozorowanie lokalizacji"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Zezwalaj na pozorowanie lokalizacji"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Czy zezwalać na debugowanie USB?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Debugowanie USB jest przeznaczone wyłącznie do celów programistycznych. Może służyć do kopiowania danych między komputerem a urządzeniem, instalowania aplikacji na urządzeniu bez powiadamiania, a także odczytu danych dziennika."</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Zezwolić na ustawienia programistyczne?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Te ustawienia są przeznaczone wyłącznie dla programistów. Ich użycie może spowodować uszkodzenie lub nieprawidłowe działanie urządzenia i zainstalowanych na nim aplikacji."</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Chroń nośnik USB"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Aplikacje muszą prosić o pozwolenie na odczyt nośnika USB"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Włączyć ochronę nośnika USB?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Gdy nośnik USB jest chroniony, aplikacje muszą prosić o pozwolenie na odczyt danych z tego nośnika zewnętrznego."\n\n"Niektóre aplikacje mogą przestać działać i wymagać aktualizacji przez programistę."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Chroń kartę SD"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Aplikacje muszą prosić o pozwolenie na odczyt karty SD"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Włączyć ochronę karty SD?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Gdy karta SD jest chroniona, aplikacje muszą prosić o pozwolenie na odczyt danych z tego nośnika zewnętrznego."\n\n"Niektóre aplikacje mogą przestać działać i wymagać aktualizacji przez programistę."</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Wybierz gadżet"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Wybierz widżet"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Utworzyć widżet i zezwolić na dostęp?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Po utworzeniu widżetu <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> może uzyskać dostęp do wszystkich wyświetlanych danych."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Zawsze zezwalaj na tworzenie widgetów przez <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> i dostęp do ich danych"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g>d <xliff:g id="HOURS">%2$d</xliff:g>g <xliff:g id="MINUTES">%3$d</xliff:g>m <xliff:g id="SECONDS">%4$d</xliff:g>s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g>g <xliff:g id="MINUTES">%2$d</xliff:g>m <xliff:g id="SECONDS">%3$d</xliff:g>s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g>m <xliff:g id="SECONDS">%2$d</xliff:g>s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g>s"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statystyki użycia"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statystyki użycia"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Sortuj wg:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacja"</string>
    <string name="launch_count_label" msgid="4019444833263957024">"Licznik"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Czas użycia"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Ułatwienia dostępu"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Ustawienia ułatwień dostępu"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Usługi"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"System"</string>
    <string name="accessibility_toggle_large_text_title" msgid="6618674985313017711">"Duży tekst"</string>
    <string name="accessibility_power_button_ends_call_title" msgid="5468375366375940894">"Przycisk kończy rozmowę"</string>
    <string name="accessibility_speak_password_title" msgid="3344423945644925355">"Wypowiadaj hasła na głos"</string>
    <string name="accessibility_long_press_timeout_title" msgid="2373216941395035306">"Czas dotknięcia i przytrzymania"</string>
    <string name="accessibility_script_injection_title" msgid="7921388904564822855">"Zwiększenie dostępności stron"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Ustawienia"</string>
    <string name="accessibility_service_state_on" msgid="8791337599927106344">"Włączone"</string>
    <string name="accessibility_service_state_off" msgid="2458594460762620776">"Wyłączone"</string>
    <string name="accessibility_script_injection_allowed" msgid="7624804397748427621">"Dozwolone"</string>
    <string name="accessibility_script_injection_disallowed" msgid="8639525487720429182">"Niedozwolone"</string>
    <string name="accessibility_script_injection_button_allow" msgid="2201503285877102870">"Zezwalaj"</string>
    <string name="accessibility_script_injection_button_disallow" msgid="5697152768523270885">"Nie zezwalaj"</string>
    <string name="accessibility_service_security_warning_title" msgid="5421628151509995404">"Użyć usługi <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_service_security_warning_summary" product="tablet" msgid="8558441850832543571">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> może gromadzić cały wpisywany tekst z wyjątkiem haseł. Dotyczy to także danych osobistych, np. numerów kart kredytowych. Może ponadto zbierać informacje o korzystaniu z tabletu."</string>
    <string name="accessibility_service_security_warning_summary" product="default" msgid="2869015914319424723">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> może gromadzić cały wpisywany tekst z wyjątkiem haseł. Dotyczy to także danych osobistych, np. numerów kart kredytowych. Może ponadto zbierać informacje o korzystaniu z telefonu."</string>
    <string name="accessibility_service_disable_warning_title" msgid="3393956845814484859">"Zatrzymać usługę <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_service_disable_warning_summary" msgid="625013894287895398">"Dotknięcie OK spowoduje zatrzymanie usługi <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Brak zainstalowanych usług"</string>
    <string name="accessibility_service_no_apps_title" msgid="5124097563864109821">"Potrzebujesz czytnika ekranu?"</string>
    <string name="accessibility_service_no_apps_message" msgid="7751662416377046539">"TalkBack odczytuje zawartość ekranu, pomagając użytkownikom niewidomym i niedowidzącym. Czy chcesz zainstalować tę usługę za darmo z Android Market?"</string>
    <string name="accessibility_script_injection_security_warning_summary" msgid="7706858873495386310">"Czy chcesz, aby aplikacje instalowały skrypty od Google, które zwiększą dostępność treści internetowych?"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Brak opisu"</string>
    <string name="settings_button" msgid="3006713718908152930">"Ustawienia"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Bateria"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Gdzie wykorzystywana jest bateria"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Brak danych o zużyciu baterii"</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Użycie baterii od odłączenia"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Użycie baterii od zresetowania"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> na baterii"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od odłączenia"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Ładowanie"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Ekran włączony"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS włączony"</string>
    <string name="battery_stats_wifi_running_label" msgid="3093545080361658269">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Aktywność"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Sygnał sieci komórkowej"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Czas aktywności urządzenia"</string>
    <string name="wifi_on_time" msgid="6310209835617490616">"Wi-Fi na czas"</string>
    <string name="bluetooth_on_time" msgid="6157799524996162271">"Wi-Fi na czas"</string>
    <string name="usage_name_percent" msgid="7976919382448235858">"<xliff:g id="NAME">%1$s</xliff:g> – <xliff:g id="NUMBER">%2$s</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Historia – szczegóły"</string>
    <string name="details_title" msgid="3792801565213935385">"Szczegóły użycia"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Szczegóły użycia"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Dostosuj wykorzystanie energii"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Dołączone pakiety"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ekran"</string>
    <string name="power_wifi" msgid="2382791137776486974">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Tryb gotowości"</string>
    <string name="power_phone" msgid="5392641106474567277">"Połączenia głosowe"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablet nieaktywny"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon nieaktywny"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"CPU łącznie"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU (pierwszy plan)"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Utrzymanie aktywności"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="8234997940652067049">"Działanie Wi-Fi"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="2857401966985425427">"Dane wysłane"</string>
    <string name="usage_type_data_recv" msgid="7251090882025234185">"Dane odebrane"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Dźwięk"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Wideo"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Czas włączenia"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Czas braku sygnału"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Wymuś zatrzymanie"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informacje o aplikacji"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Ustawienia aplikacji"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Ustawienia ekranu"</string>
    <string name="battery_action_wifi" msgid="2272741639606146903">"Ustawienia Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Ustawienia Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Użycie baterii przez połączenia głosowe"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Użycie baterii przy nieaktywnym tablecie"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Użycie baterii przy nieaktywnym telefonie"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Użycie baterii przez radio komórkowe"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Przełącz w tryb samolotowy na obszarach bez zasięgu sieci komórkowych, aby oszczędzać energię"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Użycie baterii przez wyświetlacz i podświetlenie"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Zmniejsz jasność ekranu i/lub czas jego wygaszania"</string>
    <string name="battery_desc_wifi" msgid="1702486494565080431">"Użycie baterii przez Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="2085605314976704287">"Wyłącz Wi-Fi, gdy sieć nie jest używana lub jest niedostępna."</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Użycie baterii przez Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Wyłącz moduł Bluetooth, gdy nie jest używany."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Spróbuj połączyć się z innym urządzeniem Bluetooth."</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Użycie baterii przez aplikację"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Zatrzymaj lub odinstaluj aplikację."</string>
    <string name="battery_sugg_apps_gps" msgid="7287643439298561315">"Włączaj i wyłączaj GPS ręcznie, aby kontrolować jego użycie w aplikacjach."</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacja może oferować ustawienia pozwalające zmniejszyć użycie baterii."</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od odłączenia"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Ostatnio odłączony na <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Łączne użycie"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Odśwież"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"System Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Serwer mediów"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Ustawienia głosowe"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Ustawienia funkcji głosowych"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Wyszukiwanie głosowe"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Klawiatura Android"</string>
    <string name="voice_category" msgid="1430370497125803904">"Mowa"</string>
    <string name="recognizer_title" msgid="3231385184559054457">"Moduł rozpoznawania mowy"</string>
    <string name="recognizer_settings_title" msgid="432493301215113154">"Wyszukiwanie głosowe"</string>
    <string name="recognizer_settings_summary" msgid="4472287934134546902">"Ustawienia dla „<xliff:g id="RECOGNIZER_NAME">%s</xliff:g>”"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Przetwarzanie tekstu na mowę"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Przetwarzanie tekstu na mowę"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Używaj moich ustawień"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Poniższe ustawienia domyślne zastępują ustawienia aplikacji."</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Ustawienia domyślne"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Mechanizm domyślny"</string>
    <string name="tts_default_synth_summary" msgid="6482936537135251690">"Konfiguruje mechanizm syntezy mowy używany do odczytywania tekstu"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Szybkość mowy"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Szybkość czytania tekstu"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Tony"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Określa ton czytanego tekstu"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Język"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Ustawia zależny od języka głos dla czytanych tekstów"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Posłuchaj przykładu"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Odtwórz krótką prezentację syntezy mowy"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Zainstaluj dane głosowe"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Zainstaluj dane głosowe wymagane dla syntezy mowy"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Dane głosowe wymagane dla syntezy mowy zostały już poprawnie zainstalowane"</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Ustawienia zostały zmienione. Oto przykład aktualnie skonfigurowanego brzmienia."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Nie można uruchomić wybranego mechanizmu."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Konfiguruj"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Wybierz inny mechanizm"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Ten mechanizm syntezy mowy może gromadzić cały odczytywany tekst, w tym dane osobiste w postaci haseł i numerów kart kredytowych. Nazwa mechanizmu to <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Włączyć ten mechanizm syntezy mowy?"</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Mechanizmy"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"Ustawienia <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"Mechanizm <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> jest włączony"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"Mechanizm <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> jest wyłączony"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Ustawienia mechanizmu"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Ustawienia <xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Języki i głosy"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Zainstalowano"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Nie zainstalowano"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Kobieta"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Mężczyzna"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Zainstalowano mechanizm syntezy mowy"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Najpierw włącz nowy mechanizm."</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Otwórz ustawienia mechanizmu"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Preferowany mechanizm"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Ogólne"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Zarządzanie energią"</string>
    <string name="gadget_toggle_wifi" msgid="2382963973155082629">"Aktualizowanie ustawień Wi-Fi"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Aktualizowanie ustawień Bluetooth"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Magazyn danych logowania"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Zainstaluj z nośnika"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Zainstaluj z karty SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Zainstaluj certyfikaty z nośnika"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Zainstaluj certyfikaty z karty SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Wyczyść dane o certyfikatach"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Usuń wszystkie certyfikaty"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Zaufane dane uwierzytelniające"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Wyświetlanie zaufanych certyfikatów CA"</string>
    <string name="credentials_install_gesture_prompt" msgid="2207390278112395082">"Narysuj wzór odblokowania"</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Aby potwierdzić instalację danych logowania, musisz narysować wzór odblokowania."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Podaj hasło do magazynu danych logowania."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Bieżące hasło:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Usunąć całą zawartość?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Hasło musi mieć co najmniej 8 znaków."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Nieprawidłowe hasło."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Nieprawidłowe hasło. Pozostała jedna próba przed wyczyszczeniem magazynu danych logowania."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Nieprawidłowe hasło. Pozostała liczba prób przed wyczyszczeniem magazynu danych logowania: <xliff:g id="NUMBER">%1$d</xliff:g>."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Wyczyszczono magazyn danych logowania."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Nie można wymazać magazynu."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Magazyn danych logowania jest włączony."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Aby korzystać z magazynu danych logowania, musisz ustawić kod PIN lub hasło blokady ekranu."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Sygnał alarmowy"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Skonfiguruj sposób działania w przypadku połączenia alarmowego"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Kopia i kasowanie danych"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Kopia i kasowanie danych"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Tworzenie i przywracanie kopii zapasowej"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Dane osobiste"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Utwórz kopię zapasową"</string>
    <string name="backup_data_summary" msgid="9157861529438245957">"Zapisuj na serwerach Google kopie zapasowe danych aplikacji, haseł sieci Wi-Fi i innych ustawień."</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Konto kopii zapasowej"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Żadne z kont nie przechowuje obecnie kopii zapasowej danych"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Autoprzywracanie"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Przy ponownej instalacji aplikacji przywróć ustawienia i dane z kopii zapasowej."</string>
    <!-- no translation found for bugreport_title (1009498799922543551) -->
    <skip />
    <!-- no translation found for bugreport_message (1182209569732110590) -->
    <skip />
    <!-- no translation found for report (302437572240018342) -->
    <skip />
    <string name="local_backup_password_title" msgid="3860471654439418822">"Hasło kopii zapasowych"</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"Pełne kopie zapasowe na komputerze nie są obecnie chronione."</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Wybierz, aby zmienić lub usunąć hasło pełnych kopii zapasowych na komputerze stacjonarnym."</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Nowe hasło kopii zapasowej zostało ustawione"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Nowe hasło i jego potwierdzenie nie zgadzają się"</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Ustawienie hasła kopii zapasowej nie powiodło się"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="7218566008912418809">"Zatrzymać tworzenie kopii zapasowych haseł sieci Wi-Fi, zakładek, innych ustawień oraz danych aplikacji, a także usunąć wszystkie kopie z serwerów Google?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Ustawienia administracji"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Administrator urządzenia"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Dezaktywuj"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Administratorzy urządzenia"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Brak dostępnych administratorów urządzenia"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Aktywować administratora urządzenia?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Aktywuj"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Administrator urządzenia"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Aktywowanie tego administratora zezwoli aplikacji <xliff:g id="APP_NAME">%1$s</xliff:g> na wykonywanie następujących operacji:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Administrator jest aktywny i zezwala aplikacji <xliff:g id="APP_NAME">%1$s</xliff:g> na wykonywanie następujących operacji:"</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Bez nazwy"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Ogólne"</string>
    <string name="sound_category_notification_title" msgid="3502115998790286943">"Powiadomienia"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Dzwonek i wibracje przy połączeniu"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"System"</string>
    <string name="wifi_setup_title" msgid="661074868726906436">"Konfiguracja sieci Wi-Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="7304321031985059969">"Połącz z siecią Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="3747859666621319757">"Łączenie z siecią Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>..."</string>
    <string name="wifi_setup_title_connected_network" msgid="209755856836003839">"Połączono z siecią Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Dodaj sieć"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Nie połączono"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Dodaj sieć"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Odśwież listę"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Pomiń"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Dalej"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Wróć"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Szczegóły sieci"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Połącz"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Zapomnij"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Zapisz"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Anuluj"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Skanowanie sieci…"</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Dotknij sieci, aby się z nią połączyć"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Połącz z istniejącą siecią"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Połącz z siecią niezabezpieczoną"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Podaj konfigurację sieci."</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Połącz z nową siecią"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Łączenie…"</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Przejdź do następnego etapu."</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"Protokół EAP nie jest obsługiwany."</string>
    <string name="wifi_setup_eap_not_supported" msgid="595556546597351489">"Ustawień połączenia Wi-Fi z zabezpieczeniami EAP nie można określić podczas konfiguracji. Możesz to zrobić później na ekranie Ustawienia &gt; Sieci bezprzewodowe."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Łączenie może potrwać kilka minut…"</string>
    <string name="wifi_setup_description_connected" msgid="5235991893829582459">"Dotknij opcji "<b>"Dalej"</b>", aby kontynuować konfigurację."\n\n"Wybierz "<b>"Wróć"</b>", aby połączyć się z inną siecią Wi-Fi."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Synchronizacja włączona"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Synchronizacja wyłączona"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Błąd synchronizacji"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Błąd synchronizacji"</string>
    <string name="sync_active" msgid="8476943765960863040">"Synchronizacja aktywna"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Synchronizacja"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"W tej chwili występują problemy z synchronizacją. Synchronizacja będzie możliwa wkrótce."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Dodaj konto"</string>
    <string name="background_data" msgid="5779592891375473817">"Dane w tle"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacje zawsze mogą synchronizować, wysyłać i odbierać dane."</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Wyłączyć dane w tle?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Wyłączenie obsługi danych w tle wydłuża czas pracy baterii i ogranicza transmisję danych. Niektóre aplikacje mogą nadal używać połączenia transmisji danych w tle."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Autosynchronizuj dane aplikacji"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Synchronizacja włączona"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Synchronizacja jest wyłączona"</string>
    <string name="sync_error" msgid="5060969083117872149">"Błąd synchronizacji"</string>
    <string name="last_synced" msgid="4242919465367022234">"Ostatnia synchronizacja: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Synchronizuję…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Ustawienia kopii zapasowej"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Utwórz kopię zapasową moich ustawień"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Synchronizuj teraz"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Anuluj synchronizację"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Dotknij, aby zsynchronizować<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendarz"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontakty"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Google Sync – witamy!"</font>" "\n"Synchronizacja danych daje Ci dostęp do kontaktów, wydarzeń i innych ważnych informacji z dowolnego miejsca."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Ustawienia synchronizacji aplikacji"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Dane i synchronizacja"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Zmień hasło"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Ustawienia konta"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Usuń konto"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Dodaj konto"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Zakończ"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Usunąć konto?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Usunięcie tego konta spowoduje usunięcie z tabletu wszystkich powiązanych z nim wiadomości, kontaktów i innych danych."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Usunięcie tego konta spowoduje usunięcie z telefonu wszystkich powiązanych z nim wiadomości, kontaktów i innych danych."</string>
    <string name="remove_account_failed" product="tablet" msgid="3086620478225952725">"To konto jest wymagane przez niektóre aplikacje. Możesz je usunąć wyłącznie przez przywrócenie ustawień fabrycznych tabletu (co spowoduje usunięcie wszystkich Twoich danych osobistych) w sekcji Ustawienia &gt; Kopia i kasowanie danych."</string>
    <string name="remove_account_failed" product="default" msgid="6217238709175617517">"To konto jest wymagane przez niektóre aplikacje. Możesz je usunąć wyłącznie przez przywrócenie ustawień fabrycznych telefonu (co spowoduje usunięcie wszystkich Twoich danych osobistych) w sekcji Ustawienia &gt; Kopia i kasowanie danych."</string>
    <string name="provider_label" msgid="7724593781904508866">"Subskrypcje w trybie push"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Nie można zsynchronizować ręcznie"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Synchronizacja tego elementu jest obecnie wyłączona. Aby zmienić ustawienie, tymczasowo włącz obsługę danych w tle i automatyczną synchronizację."</string>
    <string name="wimax_settings" msgid="1574837328738396794">"Ustawienia 4G"</string>
    <string name="wimax_settings_summary" msgid="3207355006084135453">"Konfiguruj sieć i modem 4G oraz zarządzaj nimi"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Adres MAC 4G"</string>
    <string name="enter_password" msgid="4131758584074246224">"Wpisz hasło, aby odszyfrować pamięć masową."</string>
    <string name="try_again" msgid="4272075051293936921">"Spróbuj ponownie."</string>
    <string name="delete" msgid="4219243412325163003">"Usuń"</string>
    <string name="misc_files" msgid="6720680815969643497">"Różne pliki"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"wybrano <xliff:g id="NUMBER">%1$d</xliff:g> z <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> z <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Wybierz wszystkie"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"Sprawdzanie HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Ustaw sprawdzanie HDCP"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Debugowanie"</string>
    <string name="debug_app" msgid="8349591734751384446">"Aplikacja do debugowania"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Nie ustawiono aplikacji do debugowania"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Aplikacja do debugowania: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Wybierz aplikację"</string>
    <string name="no_application" msgid="2813387563129153880">"Brak"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Poczekaj na debugera"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Aplikacja do debugowania czeka na przyłączenie debugera."</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Wprowadzanie"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Rysowanie"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Monitorowanie"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Tryb ścisły włączony"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Miganie ekranu podczas długich operacji w wątku głównym"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Lokalizacja wskaźnika"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Nakładka na ekranie pokazująca dane o dotyku"</string>
    <string name="show_touches" msgid="1356420386500834339">"Pokaż dotknięcia"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Potwierdzenia wizualne po dotknięciu"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Pokaż zmiany powierzchni"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Podświetlaj całe aktualizowane powierzchnie okien"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Pokaż zmiany widoku z GPU"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Podświetlaj widoki w oknach rysowane przez GPU"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Wyłącz nakładki HW"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Zawsze używaj GPU do komponowania ekranu"</string>
    <string name="enable_traces_title" msgid="7448835465859512430">"Włącz ślady"</string>
    <string name="enable_traces_dialog_title" msgid="5026490474669452929">"Wybierz włączone ślady"</string>
    <string name="enable_traces_summary_none" msgid="1867562808503494163">"Brak włączonych śladów"</string>
    <string name="enable_traces_summary_num" msgid="8978230237777454269">"Włączone ślady: <xliff:g id="NUM">%1$d</xliff:g>"</string>
    <string name="enable_traces_summary_all" msgid="3950139649125158247">"Wszystkie ślady są włączone"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Pokaż granice układu"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Pokaż granice przycięcia, marginesy itd."</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Pokaż użycie procesora"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Nakładka na ekranie pokazująca użycie procesora"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Renderowanie na GPU"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Wymuszaj użycie GPU do rysowania 2D"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profil renderowania GPU"</string>
    <string name="track_frame_time_summary" msgid="447577515813970287">"Mierz czas renderowania w adb shell dumpsys gfxinfo"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Skala animacji okna"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Skala animacji przejścia"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Skala długości animacji"</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Aplikacje"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Nie zachowuj działań"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Przerwij każde działanie, gdy użytkownik je porzuci"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Limit procesów w tle"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Pokaż wszystkie ANR"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Pokaż okno Aplikacja Nie Reaguje dla aplikacji w tle"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Użycie danych"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cykl transmisji danych"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Dane w roamingu"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Ogranicz przesył danych w tle"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Oddzielnie transmisja danych 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="8266875319417201085">"Pokaż użycie Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Pokaż użycie sieci Ethernet"</string>
    <string name="data_usage_menu_metered" msgid="5056695223222541863">"Hotspoty komórkowe"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Autosynchronizacja danych"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Zmień cykl"</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Resetowanie cyklu transmisji danych – dzień miesiąca:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"W tym okresie aplikacje nie pobierały danych."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Pierwszy plan"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Tło"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"z ograniczeniami"</string>
    <string name="data_usage_disable_mobile" msgid="5211007048880167438">"Wyłączyć transmisję komórkową?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Limit danych mobilnych"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Ustaw limit trans. danych 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Ustaw limit trans. danych 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="8575537650560665657">"Ustaw limit trans. danych Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="1728851922959017766">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobilne"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G/3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Komórkowe"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Brak"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Dane mobilne"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Transmisja danych 2G/3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Transmisja danych 4G"</string>
    <string name="data_usage_app_settings" msgid="8430240158135453271">"Wyświetl ustawienia aplikacji"</string>
    <string name="data_usage_app_restrict_background" msgid="9149728936265100841">"Ogranicz przesył danych w tle"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="518658001418490405">"Wyłącz dane w tle w sieciach komórkowych (nadal używaj w innych sieci)."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Transmisję danych w tle możesz ograniczyć po ustawieniu limitu."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Ograniczyć dane w tle?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Gdy będą dostępne tylko sieci komórkowe, funkcja ta może zakłócić działanie aplikacji, które korzystają z przesyłu danych w tle."\n\n"Szczegółowe ustawienia transmisji danych są zazwyczaj dostępne bezpośrednio w poszczególnych aplikacjach."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="7086969103661420799">"Ograniczenie transmisji danych w tle jest możliwe tylko po ustawieniu limitu komórkowej transmisji danych."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Włączyć autosynchronizację?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="7312283529426636845">"Wszystkie zmiany, które wprowadzisz na swoich kontach w sieci, będą automatycznie kopiowane na Twój tablet."\n\n"Niektóre konta mogą też kopiować do sieci wszystkie zmiany, które wprowadzisz na tablecie. W ten sposób działa konto Google."\n\n"Aby wybrać informacje synchronizowane przez poszczególne konta, wyświetl Ustawienia &gt; Konta."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="2374996799819303283">"Wszystkie zmiany, które wprowadzisz na swoich kontach w sieci, będą automatycznie kopiowane na Twój telefon."\n\n"Niektóre konta mogą też kopiować do sieci wszystkie zmiany, które wprowadzisz na telefonie. W ten sposób działa konto Google."\n\n"Aby wybrać informacje synchronizowane przez poszczególne konta, wyświetl Ustawienia &gt; Konta."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Wyłączyć autosynchronizację?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"Powoduje przesyłanie mniejszej ilości danych oraz zmniejsza użycie baterii, ale pobranie najnowszych informacji będzie wymagało ręcznej synchronizacji każdego konta. Poza tym nie będziesz otrzymywać powiadomień o aktualizacjach."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Data resetowania cyklu transmisji danych"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Data w każdym miesiącu:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Zapisz"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Ustaw ostrzeżenie o transmisji danych"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Ustaw limit danych"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Ograniczanie transmisji danych"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="3893348029612821262">"Komórkowe połączenie transmisji danych zostanie wyłączone po wyczerpaniu limitu."\n\n"Ilość przesyłanych danych może być różnie rozliczana przez tablet i operatora, więc warto ustawić nieco niższy limit."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="7962145861903746827">"Komórkowe połączenie transmisji danych zostanie wyłączone po wyczerpaniu limitu."\n\n"Ilość przesyłanych danych może być różnie rozliczana przez telefon i operatora, więc warto ustawić nieco niższy limit."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Ograniczyć dane w tle?"</string>
    <string name="data_usage_restrict_background" msgid="6387252645350792955">"Jeśli ograniczysz transmisję danych w tle, niektóre aplikacje i usługi będą działać tylko po nawiązaniu połączenia z siecią Wi-Fi."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"ostrzeżenie"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"limit"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Usunięte aplikacje"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"Odebrano: <xliff:g id="RECEIVED">%1$s</xliff:g>, wysłano: <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: wykorzystane <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="5961720793603268572">"<xliff:g id="RANGE">%2$s</xliff:g>: wykorzystane <xliff:g id="TOTAL">%1$s</xliff:g> wg licznika w tablecie. Rozliczenie operatora może się różnić."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="1625833170144610767">"<xliff:g id="RANGE">%2$s</xliff:g>: wykorzystane <xliff:g id="TOTAL">%1$s</xliff:g> wg licznika w telefonie. Rozliczenie operatora może się różnić."</string>
    <string name="data_usage_metered_title" msgid="6204750602856383278">"Hotspoty komórkowe"</string>
    <string name="data_usage_metered_body" msgid="2446827764036316131">"Wybierz sieci Wi-Fi, które są hotspotami komórkowymi. Możesz ograniczyć aplikacjom działającym w tle dostęp do tych sieci. Aplikacje mogą też ostrzegać, zanim użyją tych sieci do pobrania dużych ilości danych."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Sieci komórkowe"</string>
    <string name="data_usage_metered_wifi" msgid="4151511616349458705">"Sieci Wi-Fi"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="7566012564261138417">"Aby wybrać hotspoty komórkowe, włącz Wi-Fi."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Połączenie alarmowe"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Powrót do połączenia"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Nazwa"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Typ"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adres serwera"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Szyfrowanie PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Element tajny L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identyfikator IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Klucz wspólny IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Certyfikat użytkownika IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certyfikat CA IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certyfikat serwera IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Opcje zaawansowane"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domeny wyszukiwania DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Serwery DNS (np. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Trasy przekazywania (np. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Nazwa użytkownika"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Hasło"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Zapisz informacje o koncie"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nieużywane)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(nie weryfikuj serwera)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(odebrany z serwera)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Anuluj"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Zapisz"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Połącz"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Edytuj profil VPN"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Połącz z: <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Dodaj profil VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Edytuj profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Usuń profil"</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Brak połączenia sieciowego. Spróbuj ponownie później."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Brak certyfikatu. Edytuj profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"System"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Własne"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Wyłącz"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Włącz"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Usuń"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Włączyć systemowy certyfikat CA?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Wyłączyć systemowy certyfikat CA?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Trwale usunąć certyfikat CA użytkownika?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Sprawdzanie pisowni"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Wpisz tutaj bieżące hasło pełnych kopii zapasowych."</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Wpisz tutaj nowe hasło pełnych kopii zapasowych."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Ponownie wpisz tutaj nowe hasło pełnych kopii zapasowych."</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Ustaw hasło"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Anuluj"</string>
    <string name="percentage" msgid="5866131581207788624">"<xliff:g id="NUMBER">%d</xliff:g>%%"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Dodatkowe aktualizacje systemu"</string>
    <string name="user_settings_title" msgid="5189224330534906766">"Użytkownicy i ograniczenia"</string>
    <string name="user_list_title" msgid="2152311434413878709">"Użytkownicy"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Dodaj użytkownika"</string>
    <string name="user_details_title" msgid="3037625632127241370">"Edytuj szczegóły"</string>
    <string name="user_information_heading" msgid="8728151075759863162">"Informacje o użytkowniku"</string>
    <string name="user_name_title" msgid="7563724675699398319">"Nazwa"</string>
    <string name="user_restrictions_heading" msgid="4426403050397418553">"Ograniczenia treści"</string>
    <string name="user_market_requires_pin" msgid="3260702297207279414">"Wymagaj PIN-u"</string>
    <string name="user_max_content_rating" msgid="8297759970216482772">"Ocena treści"</string>
    <string name="user_system_apps_heading" msgid="2408331798732183682">"Aplikacje systemowe"</string>
    <string name="user_market_apps_heading" msgid="4657387297168308251">"Zainstalowane aplikacje"</string>
    <string name="user_discard_user_menu" msgid="6638388031088461242">"Odrzuć"</string>
    <string name="user_remove_user_menu" msgid="3210146886949340574">"Usuń użytkownika"</string>
    <string name="user_new_user_name" msgid="7603010274765911161">"Nieznośny dzieciak"</string>
    <string name="user_confirm_remove_title" msgid="3856148232937245711">"Usunąć użytkownika?"</string>
    <string name="user_confirm_remove_message" msgid="5284111415714437285">"Czy na pewno chcesz usunąć użytkownika i wszystkie związane z nim dane z urządzenia?"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Pokaż powiadomienia"</string>
    <string name="help_label" msgid="1107174367904110532">"Pomoc"</string>
    <string name="cell_broadcast_settings" msgid="8415582011920085222">"Transmisje komórkowe"</string>
    <string name="cell_broadcast_settings_summary" msgid="3301339398950905913">"Wybierz typy alertów o zagrożeniu, które chcesz wyświetlić."</string>
</resources>
