<?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="1999566976857398962">"Yes"</string>
    <string name="no" msgid="5541738710521607130">"No"</string>
    <string name="create" msgid="986997212165228751">"Create"</string>
    <string name="allow" msgid="3763244945363657722">"Allow"</string>
    <string name="deny" msgid="7326117222944479942">"Deny"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Turn on"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Unknown"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Tap to show info"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{You are now # step away from being a developer.}other{You are now # steps away from being a developer.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"You are now a developer!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"No need, you are already a developer."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Please enable developer options first."</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"Only the admin users can access developer settings."</string>
    <string name="header_category_system" msgid="1665516346845259058">"System"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"In service"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Out of service"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio off"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Not roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Disconnected"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Connecting"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Connected"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Suspended"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"unknown"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Preview"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Make smaller"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Make larger"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Always"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Front display turns on when you fold your device"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Only games, videos and more"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Front display turns on for apps that stop your screen going idle"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Swipe up to continue"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Fold your phone and swipe up on the front display to continue using the app, or wait a few seconds for the screen to lock"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Never"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Front display locks when you fold your device"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Use auto-rotate"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Face detection uses the front-facing camera to improve auto-rotate accuracy. Images are never stored or sent to Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Visible to all Bluetooth devices nearby (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Visible to all Bluetooth devices nearby"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Not visible to other Bluetooth devices"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Only visible to paired devices"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth devices"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Device name"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Rename this device"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Rename"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Disconnect device?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Pair new device"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Pair right ear"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Pair left ear"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Pair your other ear"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Your left hearing device is connected.\n\nTo pair the right one, make sure that it\'s turned on and ready to pair."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Your right hearing device is connected.\n\nTo pair the left one, make sure that it\'s turned on and ready to pair."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Pair right ear"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Pair left ear"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"For all available hearing devices"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Hearing device settings"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Shortcut, hearing aid compatibility"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"For this device"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio output"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"About audio output"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Route sounds to your hearing device or phone speaker"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Related"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Ringtone and alarms"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Audio during calls"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Media and system sounds"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Notifications"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"By default, audio output is determined by individual apps"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Unnamed Bluetooth device"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Searching"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"No nearby Bluetooth devices were found."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Bluetooth pairing request"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Pairing request"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Tap to pair with <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth is off"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Tap to turn it on"</string>
    <string name="device_picker" msgid="2427027896389445414">"Choose Bluetooth device"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> wants to turn on Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> wants to turn off Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"An app wants to turn on Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"An app wants to turn off Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Turning on Bluetooth…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Turning Bluetooth off…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth connection request"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Phone book access request"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Message access request"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Visible as \'<xliff:g id="DEVICE_NAME">^1</xliff:g>\' to other devices"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Turn on Bluetooth to connect to other devices."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Your devices"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Pair new device"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Disable Bluetooth A2DP hardware offload"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Disable Bluetooth LE audio hardware offload"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Restart device?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"You need to restart your device to change this setting."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Restart"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Cancel"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Disable Bluetooth LE audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Disables the Bluetooth LE audio feature if the device supports LE audio hardware capabilities."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Show LE Audio toggle in Device details"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Bypass Bluetooth LE Audio allowlist"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Use LE Audio by default even if LE Audio peripheral hasn\'t been verified to meet allowlist criteria."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Media devices"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Call devices"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Other devices"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Saved devices"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Associated with account"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Previously used with account"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth will turn on to pair"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Connection preferences"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Previously connected"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth turned on"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"See all"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"See all"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stylus"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Tail button press"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (Work profile)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Write in text fields"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignore all stylus button presses"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stylus"</string>
    <string name="audio_sharing_title" msgid="4144157137502923821">"Audio sharing"</string>
    <string name="audio_sharing_switch_title" msgid="7052827328670825701">"Share audio"</string>
    <string name="calls_and_alarms_device_title" msgid="6993559028175454198">"Calls and alarms"</string>
    <string name="audio_streams_category_title" msgid="4878022761829895463">"Connect to an LE audio stream"</string>
    <string name="audio_streams_pref_title" msgid="6320485086288646209">"Nearby audio streams"</string>
    <string name="audio_streams_title" msgid="6617990880383079165">"Audio streams"</string>
    <string name="audio_streams_qr_code_summary" msgid="2838923349871884871">"Connect to an audio stream using QR code"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"No nearby audio streams were found."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Date and time"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Clear"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Proxy port"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Bypass proxy for"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Restore defaults"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Done"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Proxy hostname"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Attention"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"The hostname that you typed isn\'t valid."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"The exclusion list that you\'ve typed isn\'t properly formatted. Type a comma-separated list of excluded domains."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"You need to complete the port field."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"The port field must be empty if the host field is empty."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"The port that you typed is not valid."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"The HTTP proxy is used by the browser but may not be used by other apps."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ping Hostname(www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP Client test:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Run ping test"</string>
    <string name="skip_label" msgid="6380034601349015895">"Skip"</string>
    <string name="next_label" msgid="1248293387735652187">"Next"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Languages"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Preferred language order"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"System language"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Remove"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Add a language"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Language"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Preferred language"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"App languages"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Set the language for each app"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"App language"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Suggested languages"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"All languages"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"System language"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"System default"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Language selection for this app isn’t available from Settings."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Language may differ from languages available in the app. Some apps may not support this setting."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Set the language for each app."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Your system, apps and websites use the first supported language from your preferred languages."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"To select a language for each app, go to app language settings."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Learn more about app languages"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Change system language to %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Add %s to preferred languages?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"This lets apps and websites know that you also prefer this language."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Your device settings and regional preferences will change."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Change"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s not available"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"This language can’t be used as a system language, but you’ve let apps and websites know that you prefer this language."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regional preferences"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Set units and number preferences"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Let apps know your regional preferences so that they can personalise your experience."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Apps will use your regional preferences where possible."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperature"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"First day of week"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Numbers preferences"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Use default"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Sunday"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Monday"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Tuesday"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Wednesday"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Thursday"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Friday"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Saturday"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"If an app doesn’t support regional preferences, the app will use its default locale settings."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Learn more about language preferences."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Additional preferences"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Terms of address"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Set how you want to be addressed"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Apps can use your terms of address to personalise how they address you."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Not specified"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Feminine"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Masculine"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutral"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Remove selected language?}other{Remove selected languages?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Text will be displayed in another language."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Can’t remove all languages"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Keep at least one preferred language"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Not available as system language"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Move up"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Move down"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Move to top"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Move to bottom"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Remove language"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Choose activity"</string>
    <string name="cancel" msgid="5780102414089664898">"Cancel"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Forget"</string>
    <string name="save" msgid="3125033126936493822">"Save"</string>
    <string name="done" msgid="7497982645646431310">"Done"</string>
    <string name="apply" msgid="7834684883190163536">"Apply"</string>
    <string name="share" msgid="8502235338607613795">"Share"</string>
    <string name="add" msgid="8335206931421683426">"Add"</string>
    <string name="remove" msgid="1028414219245072102">"Remove"</string>
    <string name="settings_label" msgid="943294133671632976">"Settings"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Settings"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Settings shortcut"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Aeroplane mode"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Wireless &amp; networks"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Connect to data services when roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Connect to data services when roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Roaming charges may apply."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Set time automatically"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Set automatically"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Location will be used for setting the time zone when this toggle is on"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Use locale default"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Use 24-hour format"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Time"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Time format"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Time zone"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Select time zone"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Date"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Search region"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Region"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Select UTC offset"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Uses <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> starts on <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Uses <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. No daylight savings time."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"British Summer Time (also known as daylight savings time)"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standard time"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Select by region"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Select by UTC offset"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Lock after screen timeout"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> after timeout"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Immediately after timeout, except when kept unlocked by <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> after timeout, except when kept unlocked by <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Add text on lock screen"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"None"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"e.g. Joe\'s Android."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Location"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Use location"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Off"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{On / # app has access to location}other{On / # apps have access to location}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Loading…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Apps with the Nearby devices permission can determine the relative position of connected devices."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Location access is off for apps and services. Your device location may still be sent to emergency responders when you call or text an emergency number."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Learn more about location settings"</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"To change location access, go to Settings &gt; Security and privacy &gt; Privacy controls"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Accounts"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Security"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Encryption and credentials"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Lock screen"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"What to show"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Not available"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Security status"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Screen lock, Find My Device, app security"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Security and privacy"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"App security, device lock, permissions"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Face added"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Setup needed"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Face Unlock"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Face Unlock for work"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"How to set up Face Unlock"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Set up Face Unlock"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Use your face to authenticate"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Start"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"If accessibility Face Unlock is turned off, some setup steps may not work properly with TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Go back"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Continue setup"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Use accessibility setup"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Cancel"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"No, thanks"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"I agree"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"More"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Unlock with your face"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Allow face unlock"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Use your face to authenticate"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Use your face to unlock your phone or approve purchases.\n\nNote: You can’t use your face to unlock this device. For more information, contact your organisation’s admin."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Use your face to unlock your phone, authorise purchases or sign in to apps"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Centre your face in the circle"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Skip"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"You’ve added the maximum number of faces"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Can’t add more faces"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Enrolment was not completed"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Face enrolment time limit reached. Try again."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Face enrolment didn\'t work."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"All set. Looking good."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Done"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Improve Face Unlock performance"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Set up Face Unlock again"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Set up Face Unlock again"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Improve security and performance"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Set up Face Unlock"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Delete your current face model to set up Face Unlock again.\n\nYour face model will be permanently and securely deleted.\n\nAfter deletion, you will need your PIN, pattern or password to unlock your phone or for authentication in apps."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Delete your current face model to set up Face Unlock again.\n\nYour face model will be permanently and securely deleted.\n\nAfter deletion, you will need your fingerprint, PIN, pattern or password to unlock your phone or for authentication in apps."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Use Face Unlock to"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"When using Face Unlock"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Require eyes to be open"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"To unlock the phone, your eyes must be open"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Always require confirmation"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"When using Face Unlock in apps, always require confirmation step"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Delete face model"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Set up Face Unlock"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Delete face model?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your PIN, pattern or password to unlock your phone or for authentication in apps."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your PIN, pattern or password to unlock your phone."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your fingerprint, PIN, pattern or password to unlock your phone or for authentication in apps."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your fingerprint, PIN, pattern or password to unlock your phone."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Use Face Unlock to unlock your phone"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Fingerprint"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Fingerprint"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"When using Fingerprint Unlock"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Fingerprint for work"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Add fingerprint"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Fingerprint added}other{# fingerprints added}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Setup needed"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Set up your fingerprint"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Allow Fingerprint Unlock"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Use your fingerprint"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Learn more about Fingerprint Unlock"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"You\'re in control"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"You and your child are in control"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Bear in mind"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Use your fingerprint to unlock your phone or approve purchases.\n\nNote: You can’t use your fingerprint to unlock this device. For more information, contact your organisation’s admin."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Cancel"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"No, thanks"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"I agree"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Skip fingerprint?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Fingerprint setup only takes a minute or two. If you skip this, you can add your fingerprint later in Settings."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"When you see this icon, use your fingerprint for authentication, like when you sign in to apps or approve a purchase"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Bear in mind"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"How it works"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Fingerprint Unlock creates a unique model of your fingerprint to verify that it’s you. To create this fingerprint model during setup, you will take images of your fingerprint from different positions."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Fingerprint Unlock creates a unique model of your child’s fingerprint to verify that it’s them. To create this fingerprint model during setup, they will take images of their fingerprint from different positions."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"For best results, use a screen protector that’s Made For Google certified. With other screen protectors, your fingerprint may not work."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"For best results, use a screen protector that’s Made For Google certified. With other screen protectors, your child’s fingerprint may not work."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Watch Unlock"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"When you set up Face Unlock and Fingerprint Unlock, your phone will ask for your fingerprint when you wear a mask or are in a dark area.\n\nWatch Unlock is another convenient way to unlock your phone, for example, when your fingers are wet or face isn’t recognised."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"Watch Unlock is another convenient way to unlock your phone, for example, when your fingerprint isn’t recognised."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"Watch Unlock is another convenient way to unlock your phone, for example, when your face isn’t recognised."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Use fingerprint or watch to"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Use face or watch to"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Use face, fingerprint or watch to"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Use watch to"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Using face or watch"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Using fingerprint or watch"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Using face, fingerprint or watch"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Using watch"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Set up Face or Fingerprint Unlock first"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"You can unlock with your watch when your face or fingerprint isn’t recognised"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Set up Fingerprint Unlock first"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"You can unlock with your watch when your fingerprint isn’t recognised"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Set up Face Unlock first"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"You can unlock with your watch when your face isn’t recognised"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Set up"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Fingerprint and <xliff:g id="WATCH">%s</xliff:g> added"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Fingerprints and <xliff:g id="WATCH">%s</xliff:g> added"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Face and <xliff:g id="WATCH">%s</xliff:g> added"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Face, fingerprint and <xliff:g id="WATCH">%s</xliff:g> added"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Face, fingerprints and <xliff:g id="WATCH">%s</xliff:g> added"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Remote authenticator unlock"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Watch added"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Set up your watch"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Watch Unlock is another convenient way to unlock this phone, for example, when your fingers are wet or face isn\'t recognised.\n\nYou can use your watch to unlock this phone when you:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Not now"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Continue"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"More"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"How it works"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Your watch must be unlocked, on your wrist and within reach of this phone. You won\'t need to unlock your watch again while it\'s on your wrist."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"When this phone is unlocked, you\'ll get notified on your watch. If it was unlocked when you didn\'t intend to, tap the notification to lock the phone again."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"You\'re in control"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"You can remove your watch from Watch Unlock at any time in Settings"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Tap a notification"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Swipe up on the lock screen"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Choose your watch"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Available watches"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Cancel"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Confirm"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"You\'re ready to go!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"You can now use your watch to unlock this phone when you swipe up on the lock screen or tap a notification"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Done"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Watch Unlock"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"You can use your watch to unlock this phone when you swipe up on the lock screen or tap a notification"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"To use Watch Unlock, your watch must be unlocked, on your wrist, within reach and connected to this phone. If the connection is interrupted, you\'ll need to unlock the phone before you can use Watch Unlock.\n\nKeep in mind:\nYou can only have one watch set up at a time. To add another watch, remove the current one first."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Learn more about Watch Unlock"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Add watch"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Remove watch"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Fingerprint and Face Unlock"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Face and Fingerprint Unlock for work"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Setup needed"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Face and fingerprints added"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Face and fingerprint added"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"When you set up Face Unlock and Fingerprint Unlock, your phone will ask for your fingerprint when you wear a mask or are in a dark area"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Ways to unlock"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Use face or fingerprint to"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Unlock your phone"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Verify that it’s you in apps"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Using face"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Using fingerprint"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Using face or fingerprint"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Can’t set up Face Unlock"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Exit split screen to set up Face Unlock"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Can\'t set up fingerprint"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Exit split screen to set up Fingerprint Unlock"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Skip screen lock?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Skip anyway"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Go back"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Skip"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Cancel"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Touch the sensor"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Touch the power button without pressing it"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"How to set up your fingerprint"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"It\'s on the back of your phone. Use your index finger."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"The fingerprint sensor is on your screen. You’ll capture your fingerprint on the next screen."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Start"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Move your finger across the screen to find the sensor. Touch &amp; hold the fingerprint sensor."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Illustration with device and fingerprint sensor location"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Name"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Try again"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Delete"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Touch the sensor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Put your finger on the sensor and lift after you feel a vibration"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Keep your fingerprint flat on the sensor until you feel a vibration"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Without pressing the button, keep your fingerprint on the sensor until you feel a vibration.\n\nMove your finger slightly each time. This helps capture more of your fingerprint."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Touch and hold the fingerprint sensor"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Lift, then touch again"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"One more time"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Follow the fingerprint icon"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Keep lifting your finger to add the different parts of your fingerprint"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Touch and hold each time the fingerprint icon moves. This helps capture more of your fingerprint."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Place the tip of your finger on the sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Place the left edge of your finger"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Place the right edge of your finger"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Place the centre part of your finger on the sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Place the tip of your finger on the sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Place the left edge of your finger on the sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Finally, place the right edge of your finger on the sensor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Place the side of your fingerprint on the sensor and hold, then switch to the other side"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"This helps capture more of your fingerprint"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Enrolling fingerprint <xliff:g id="PERCENTAGE">%d</xliff:g> per cent"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Enrolled <xliff:g id="PERCENTAGE">%d</xliff:g> per cent"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Enrolling fingerprint <xliff:g id="PERCENTAGE">%d</xliff:g> per cent"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Fingerprint added"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Touch to unlock at any time"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Touch the sensor to unlock, even when the screen is off. This makes accidental unlocking more likely."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Screen, unlock"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Do it later"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Lift, then touch again"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Place the side of your fingerprint on the sensor and hold, then switch to the other side"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Skip fingerprint setup?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"You’ve chosen to use your fingerprint as one way to unlock your phone. If you skip now, you’ll need to set this up later. Setup takes only a minute or so."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Skip setup for <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Skip PIN setup?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Skip setup for PIN and face?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Skip setup for PIN and fingerprint?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Skip setup for PIN, face and fingerprint?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Skip password setup?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Skip setup for password and face?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Skip setup for password and fingerprint?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Skip setup for password, face and fingerprint?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Skip pattern setup?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Skip setup for pattern and face?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Skip setup for pattern and fingerprint?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Skip setup for pattern, face and fingerprint?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Set up screen lock"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Done"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Whoops, that\'s not the sensor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Touch the sensor on the back of your phone. Use your index finger."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Can\'t complete fingerprint setup"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"You can try again now or set up your fingerprint later in Settings."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"You can try again now or set up your fingerprint later."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Fingerprint setup timed out"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"You can set up your fingerprint later in Settings."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Something went wrong. You can set up your fingerprint later in Settings."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"You can set up your fingerprint later."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Something went wrong. You can set up your fingerprint later."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Add another"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Next"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"The screen lock option is disabled. To find out more, contact your organisation’s admin."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"You can still use your fingerprint to authorise purchases and app access."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Lift finger, then touch sensor again"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Can\'t use fingerprint sensor"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Visit a repair provider."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"More security settings"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Work profile lock, encryption and more"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Encryption, credentials and more"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"security, more security settings, more settings, advanced security settings"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"More privacy settings"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"More security and privacy"</string>
    <string name="security_header" msgid="961514795852103424">"Security"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privacy"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Work profile"</string>
    <string name="private_space_title" msgid="7078627930195569767">"Private Space"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Keep private apps locked and hidden"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Keep private apps in a separate space that you can hide or lock"</string>
    <string name="private_space_lock_title" msgid="3006539720164938296">"Private Space lock"</string>
    <string name="private_space_one_lock_summary" msgid="2759953747682959371">"You can unlock Private Space the same way that you unlock your device, or choose a different lock"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Use device screen lock"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Face and Fingerprint Unlock"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Fingerprint Unlock"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Face Unlock"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Tap to set up"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="5804023571114910034">"Fingerprint Unlock for private space"</string>
    <string name="private_space_face_unlock_title" msgid="6613018437620070183">"Face Unlock for private space"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Ways to unlock"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Same as device screen lock"</string>
    <string name="private_space_new_lock_title" msgid="7306873010565337671">"Choose a new lock for Private Space?"</string>
    <string name="private_space_auto_lock_title" msgid="4757097802686131305">"Lock automatically"</string>
    <string name="private_space_auto_lock_page_title" msgid="2993714305725968632">"Lock private space automatically"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"You can lock your private space automatically if you haven\'t used your device for a period of time"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Every time device locks"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"After 5 minutes of inactivity"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Never"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Hide when locked"</string>
    <string name="privatespace_hide_page_title" msgid="972581369094289386">"Hide Private Space when locked"</string>
    <string name="privatespace_hide_page_summary" msgid="1052569521186403642">"To stop other people knowing Private Space is on your device, you can hide it from your apps list"</string>
    <string name="privatespace_access_header" msgid="982809349769470185">"Access Private Space when hidden"</string>
    <string name="privatespace_search_description" msgid="983837656432484282">"Search for \'Private Space\' in the search bar"</string>
    <string name="privatespace_tap_tile_description" msgid="4146608898639668340">"Tap the Private Space tile"</string>
    <string name="privatespace_unlock_description" msgid="4132755357482447360">"Unlock your Private Space"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Off"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"On"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"System"</string>
    <string name="private_space_delete_title" msgid="3075645119800272800">"Delete Private Space"</string>
    <string name="private_space_deleted" msgid="7825768516955610897">"Private Space successfully deleted"</string>
    <string name="private_space_delete_failed" msgid="8500755484258565011">"Private Space could not be deleted"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Private space unlocked"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Set a screen lock"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"To use your private space, set a screen lock on this device"</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Set screen lock"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Cancel"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Cancel"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Set up"</string>
    <string name="private_space_setup_title" msgid="7091257695872833671">"Set up a private space"</string>
    <string name="private_space_hide_apps_summary" msgid="6272406822568588610">"Keep private apps in a separate space that you can hide or lock"</string>
    <string name="private_space_how_title" msgid="6878224242661347658">"How it works"</string>
    <string name="private_space_access_bottom_text" msgid="8931773427017046981">"You can access your private space from the bottom of your apps list"</string>
    <string name="private_space_protected_lock_text" msgid="3926344387256377994">"Apps in your private space are protected by a lock"</string>
    <string name="private_space_hidden_notifications_text" msgid="1487992156742340621">"Notifications from apps in your private space are hidden when it’s locked"</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Apps in your private space won\'t appear in permission manager, privacy dashboard and other settings when your private space is locked.\n\nYour private space can\'t be moved to a new device. You\'ll need to set up another private space if you want to use it on another device.\n\nAnyone that connects your device to a computer or installs harmful apps on your device may be able to access your private space."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Setting up private space…"</string>
    <string name="private_space_notifications_hidden_title" msgid="4377296080723608107">"Notifications from apps in private space are hidden when it’s locked"</string>
    <string name="private_space_share_photos_title" msgid="2102594859384040485">"Unlock private space to share photos or files from private space apps"</string>
    <string name="private_space_apps_installed_title" msgid="2428207301009983268">"Some apps are already installed in your private space"</string>
    <string name="private_space_error_screen_title" msgid="1210906480024148398">"Couldn’t set up private space"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Try again"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Use screen lock to unlock private space?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"You can unlock your private space the same way you unlock your device, or choose a different lock"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Use screen lock"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Choose new lock"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"All set!"</string>
    <string name="private_space_access_text" msgid="4258842502257201013">"To access your private space, go to your apps list, then scroll down"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Done"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Scroll down to find private space"</string>
    <!-- no translation found for private_space_retry_signin_title (8090276618867918844) -->
    <skip />
    <!-- no translation found for private_space_retry_summary (1920444015972648774) -->
    <skip />
    <!-- no translation found for private_space_skip_login_label (7078019409056628192) -->
    <skip />
    <!-- no translation found for private_space_continue_login_label (7779965766333065391) -->
    <skip />
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Choose a lock for your private space"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"You can unlock your private space using your fingerprint. For security, this option requires a backup lock."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Set a PIN for your private space"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Set a password for your private space"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Set a pattern for your private space"</string>
    <string name="privatespace_unhide_header" msgid="1192011539687584004">"To show Private Space (not final UX)"</string>
    <string name="privatespace_open_settings" msgid="5038101805604421393">"Open the Settings app"</string>
    <string name="privatespace_tap_settings" msgid="928932826450238276">"Tap on Security &amp; privacy &gt; Private Space &gt; Hide Private Space when locked"</string>
    <string name="privatespace_turnoff_hide" msgid="4858511423837613842">"Turn off \'Hide Private Space when locked\' toggle"</string>
    <string name="privatespace_development_note" msgid="2999992301558700721">"Note to Googlers: The development of this feature is still in progress"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"You can add up to <xliff:g id="COUNT">%d</xliff:g> fingerprints"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"You’ve added the maximum number of fingerprints"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Can’t add more fingerprints"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Delete \'<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\'"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"You won\'t be able to use your fingerprint to unlock your work profile, authorise purchases or sign in to work apps."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Encryption"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Encrypted"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Set a screen lock"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"For added security, set a PIN, pattern or password for this device."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Set screen lock"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Set a screen lock"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"For added security, set a PIN, pattern or password for this device."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Secure your phone"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Add fingerprint to unlock"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Choose screen lock"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Choose a screen lock"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Choose a new screen lock"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Choose a lock for work apps"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Choose a new work lock"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"For added security, set a backup screen lock"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Choose your backup screen lock method"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"If you forget your screen lock, your IT admin can’t reset it."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Set a separate work lock"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"If you forget this lock, ask your IT admin to reset it"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Screen lock options"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Screen lock options"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Auto-confirm unlock"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Unlock automatically if you input a correct PIN of 6 digits or more. This is slightly less secure than tapping Enter to confirm."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Auto-confirm correct PIN"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Confirming your PIN by tapping Enter is more secure than using auto-confirm"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Enter device PIN to enable auto-confirm"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Enter device PIN to disable auto-confirm"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Screen lock"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Work profile lock"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"None"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Swipe"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Pattern"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Password"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Not now"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Current screen lock"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Pattern • Fingerprint"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Fingerprint"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Password • Fingerprint"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Continue without fingerprint"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Pattern • Face"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Face"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Password • Face"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Continue without Face Unlock"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Continue without fingerprint or face"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"None"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Swipe"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Pattern"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Password"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Delete screen lock?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Remove profile protection?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"A pattern protects your phone if it’s lost or stolen"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"A pattern protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>This also deletes the fingerprint model stored on your device. You won’t be able to use your fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"A pattern protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>Your face model will also be permanently and securely deleted. You won’t be able to use your face for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"A pattern protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won’t be able to use your face or fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"A PIN protects your phone if it’s lost or stolen"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"A PIN protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>This also deletes the fingerprint model stored on your device. You won’t be able to use your fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"A PIN protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>Your face model will also be permanently and securely deleted. You won’t be able to use your face for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"A PIN protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won’t be able to use your face or fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"A password protects your phone if it’s lost or stolen"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"A password protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>This also deletes the fingerprint model stored on your device. You won’t be able to use your fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"A password protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>Your face model will also be permanently and securely deleted. You won’t be able to use your face for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"A password protects your phone if it’s lost or stolen.<xliff:g id="EMPTY_LINE">

</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won’t be able to use your face or fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Device protection features will not work without your screen lock."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Device protection features will not work without your screen lock.<xliff:g id="EMPTY_LINE">

</xliff:g>This also deletes the fingerprint model stored on your device. You won’t be able to use your fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Device protection features will not work without your screen lock.<xliff:g id="EMPTY_LINE">

</xliff:g>Your face model will also be permanently and securely deleted. You won’t be able to use your face for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Device protection features will not work without your screen lock.<xliff:g id="EMPTY_LINE">

</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won’t be able to use your face or fingerprint for authentication in apps."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Delete"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> recommends a strong PIN or password and may not work as expected without one"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> recommends a new PIN or password and may not work as expected without one"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> recommends a new pattern, PIN or password and may not work as expected without one"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> recommends a new screen lock"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Try again. Attempt <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> of <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Your data will be deleted"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"If you enter an incorrect pattern on the next attempt, this device\'s data will be deleted"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"If you enter an incorrect PIN on the next attempt, this device\'s data will be deleted"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"If you enter an incorrect password on the next attempt, this device\'s data will be deleted"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"If you enter an incorrect pattern on the next attempt, this user will be deleted"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"If you enter an incorrect PIN on the next attempt, this user will be deleted"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"If you enter an incorrect password on the next attempt, this user will be deleted"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"If you enter an incorrect pattern on the next attempt, your work profile and its data will be deleted"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"If you enter an incorrect PIN on the next attempt, your work profile and its data will be deleted"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"If you enter an incorrect password on the next attempt, your work profile and its data will be deleted"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Must contain at least # character}other{Must be at least # characters}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{If using only numbers, must be at least 1 digit}other{If using only numbers, must be at least # digits}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN must contain at least # digit}other{PIN must be at least # digits}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN must contain at least # digit, but a {minAutoConfirmLen}-digit PIN is recommended for added security}other{PIN must be at least # digits, but a {minAutoConfirmLen}-digit PIN is recommended for added security}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Must be fewer than # character}other{Must be fewer than # characters}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Must be fewer than # digit}other{Must be fewer than # digits}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Device admin doesn\'t allow using a recent PIN"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"This can\'t include an invalid character"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Must contain at least 1 letter}other{Must contain at least # letters}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Must contain at least 1 lowercase letter}other{Must contain at least # lowercase letters}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Must contain at least 1 uppercase letter}other{Must contain at least # uppercase letters}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Must contain at least 1 numeric digit}other{Must contain at least # numeric digits}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Must contain at least 1 special symbol}other{Must contain at least # special symbols}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Must contain at least 1 non-letter character}other{Must contain at least # non-letter characters}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Must contain at least 1 non-numeric character}other{Must contain at least # non-numeric characters}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Device admin doesn\'t allow using a recent password"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Ascending, descending or repeated sequence of digits isn\'t allowed"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Confirm"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Clear"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Screen lock was already changed. Try again with the new screen lock."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Cancel"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Next"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Device admin apps"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"No active apps"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# active app}other{# active apps}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Trust agents"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"To use, first set a screen lock"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"None"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 active trust agent}other{# active trust agents}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Pair with <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Add new member to the existing coordinated set"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetooth pairing code"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Type the pairing code then press Return or Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN contains letters or symbols"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Usually 0000 or 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Must be 16 digits"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"You may also need to type this PIN on the other device."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"You may also need to type this passkey on the other device."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Confirm to pair with the coordinated set"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Allow access to your contacts and call history"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Also allow access to contacts and call history"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Info will be used for call announcements and more"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Couldn\'t connect to <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Available devices"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Connect"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Disconnect"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Pair &amp; connect"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"When Bluetooth is turned on, your device can communicate with other nearby Bluetooth devices"</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"When Bluetooth is turned on, your device can communicate with other nearby Bluetooth devices.\n\nTo improve device experience, apps and services can still scan for nearby devices at any time, even when Bluetooth is off. This can be used, for example, to improve location-based features and services. You can change this in Bluetooth scanning settings."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Change"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Device details"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Keyboard settings"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Device\'s Bluetooth address: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Device\'s Bluetooth address:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Forget device?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Remove association"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Disconnect app?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"<xliff:g id="APP_NAME">%1$s</xliff:g> app will no longer connect to your <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Experimental. Improves audio quality."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Forget device"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Disconnect app"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maximum connected Bluetooth audio devices"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Select maximum number of connected Bluetooth audio devices"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"NFC stack debug log"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Increase NFC stack logging level"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"NFC verbose vendor debug log"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Include additional device-specific vendor logs in bug reports, which may contain private information."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"NFC NCI unfiltered log"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Capture detailed NFC packets, which may contain private information."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Restart device?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Detailed NFC logging is intended for development purposes only. Additional NFC data is included in bug reports, which may contain private information. Restart your device to change this setting."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Restart"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Cast"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"mirror"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Enable wireless display"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"No nearby devices were found."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Connecting"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Connected"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"In use"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Unavailable"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Wireless display options"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Forget"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Done"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Name"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2.4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Sign in"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Open site"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> left"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Expires on <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> wants to turn on Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> wants to turn off Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verify bytecode of debuggable apps"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Allow ART to verify bytecode for debuggable apps"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Show refresh rate"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Show the current display refresh rate"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Show HDR/SDR ratio"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Show the current HDR/SDR ratio"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Require device unlock for NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Ready to transmit app content via NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Off"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Unavailable because NFC is turned off"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"When this feature is turned on, you can beam app content to another NFC-capable device by holding the devices close together. For example, you can beam web pages, YouTube videos, contacts and more.\n\nJust bring the devices together (typically back to back) and then tap your screen. The app determines what gets beamed."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi‑Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Use Wi‑Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Wi‑Fi settings"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Select Wi‑Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Turning Wi‑Fi on…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Turning off Wi‑Fi…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Error"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz band not available in this country"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"In aeroplane mode"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Notify for public networks"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Notify when a high‑quality public network is available"</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Allow WEP networks"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"WEP is an older security protocol that\'s less secure"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Your operator doesn\'t allow WEP networks because they\'re less secure"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Turn on Wi‑Fi automatically"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi‑Fi will turn back on near high‑quality saved networks, like your home network"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Unavailable because location is turned off. Turn on "<annotation id="link">"location"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Install certificates"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"To improve location accuracy, apps and services can still scan for Wi‑Fi networks at any time, even when Wi‑Fi is off. This can be used, for example, to improve location-based features and services. You can change this in <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Wi‑Fi scanning settings<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"To improve location accuracy, turn on Wi-Fi scanning in <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Wi‑Fi scanning settings<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Switch to mobile data automatically"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Use mobile data when Wi‑Fi has no Internet access. Data usage charges may apply."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Add network"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Wi‑Fi preferences"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi turns back on automatically"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi doesn\'t turn back on automatically"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"To see available networks, turn Wi‑Fi on."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Searching for networks…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"You don\'t have permission to change the Wi‑Fi network."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Turn on Wi‑Fi scanning?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"To turn on Wi‑Fi automatically, you first need to turn on Wi‑Fi scanning."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Wi‑Fi scanning allows apps and services to scan for Wi‑Fi networks at any time, even when Wi‑Fi is off. This can be used, for example, to improve location‑based features and services."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Turn on"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Wi‑Fi scanning turned on"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"This network uses an older security protocol that\'s less secure"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"<xliff:g id="NAME">%1$s</xliff:g> is blocked"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"This network uses an older security protocol called WEP, which is less secure. To connect anyway, you can allow WEP networks."</string>
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Your operator doesn\'t allow you to connect to this network because it uses an older security protocol that’s less secure"</string>
    <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Allow WEP"</string>
    <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Close"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Advanced options"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Drop-down list Advanced Options"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expand"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Network name"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Enter the SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Security"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Hidden network"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"If your router is not broadcasting a network ID but you would like to connect to it in the future, you can set the network as hidden.\n\nThis may create a security risk because your phone will regularly broadcast its signal to find the network.\n\nSetting the network as hidden will not change your router settings."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signal strength"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Transmit link speed"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Receive link speed"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Link speed"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frequency"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP address"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Saved via"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"<xliff:g id="NAME">%1$s</xliff:g> credentials"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP method"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Phase 2 authentication"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA certificate"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimum TLS version"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Online certificate status"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domain"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"User certificate"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identity"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonymous identity"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Password"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Show password"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2.4 GHz band"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"5.0 GHz band preferred"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP settings"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privacy"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Subscription"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"View or change subscription"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Randomised MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Add a device"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centre the QR code below to add the device to \'<xliff:g id="SSID">%1$s</xliff:g>\'"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Scan QR code"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centre the QR code below to connect to \'<xliff:g id="SSID">%1$s</xliff:g>\'"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Join Wi‑Fi by scanning a QR code"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Share Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Scan this QR code with another device to join \'<xliff:g id="SSID">%1$s</xliff:g>\'"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Scan this QR code to connect to \'<xliff:g id="SSID">%1$s</xliff:g>\'"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Try again. If the issue continues, contact the device manufacturer"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Something went wrong"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Make sure that the device has been plugged in, charged and turned on"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Make sure that the device has been plugged in, charged and turned on. If the issue continues, contact the device manufacturer"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Adding \'<xliff:g id="SSID">%1$s</xliff:g>\' isn’t supported by this device"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Try moving the device closer to your Wi‑Fi access point/router"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Check the password and try again"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Contact the device manufacturer"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Check connection and try again"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Choose network"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"To connect your device, choose a network"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Add this device to \'<xliff:g id="SSID">%1$s</xliff:g>\'?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi shared with device"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Add another device"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Choose different network"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Couldn’t add device"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Device found"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Sharing Wi‑Fi with this device…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Connecting…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Share hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Verify that it\'s you"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Wi‑Fi password: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Hotspot password: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Auto‑connect"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Allow connection to this network when in range"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Add device"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Use a QR code to add a device to this network"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR code isn\'t a valid format"</string>
    <string name="retry" msgid="7542103800274026915">"Retry"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Share with other device users"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(unchanged)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Please select"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Multiple certificates added)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Use system certificates"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Do not provide"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Trust on first use"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Network name is too long."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Must specify a domain."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Certificate required."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"To improve location accuracy and for other purposes, <xliff:g id="APP_NAME">%1$s</xliff:g> wants to turn on network scanning, even when Wi-Fi is off.\n\nAllow this for all apps that want to scan?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"To improve location accuracy and for other purposes, an unknown app wants to turn on network scanning, even when Wi‑Fi is off.\n\nAllow this for all apps that want to scan?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Allow"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Deny"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"This network has no Internet access. Stay connected?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Some apps and services may not work due to limited connectivity. Use anyway?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Don\'t ask again for this network"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi‑Fi is not connected to the Internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"You can switch to the mobile network whenever Wi‑Fi has a bad connection. Data usage charges may apply."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Switch to mobile"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Stay on Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Never show again"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Connect"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Connected to <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Connecting…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Failed to connect to network"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Network not in range"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Forget"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Modify"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Save"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Failed to save network"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Cancel"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Forget network?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 network}other{# networks}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 subscription}other{# subscriptions}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 network &amp; subscription}other{# networks &amp; subscriptions}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Device MAC address"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Randomised MAC address"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Randomised MAC address (last used)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Network details"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Subnet mask"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Type"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6 addresses"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Hotspot device details"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Internet source"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi‑Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Mobile data"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> – charging"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Hotspot connection"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Connection strength"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Saved networks"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Subscriptions"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Other networks"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Please type a valid IP address."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Please type a valid gateway address."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Type a valid DNS address."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Type a network prefix length between 0 and 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (unless overridden by private DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (unless overridden by private DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Network prefix length"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Search for devices"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Searching…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Rename device"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Peer devices"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Remembered groups"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Could not connect."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Failed to rename device."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Disconnect?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"If you disconnect, your connection with <xliff:g id="PEER_NAME">%1$s</xliff:g> will end."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"If you disconnect, your connection with <xliff:g id="PEER_NAME">%1$s</xliff:g> and <xliff:g id="PEER_COUNT">%2$s</xliff:g> other devices will end."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Cancel invitation"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Do you want to cancel invitation to connect with <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Forget this group?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wi‑Fi hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Not sharing Internet or content with other devices"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"No password set"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Hotspot name"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Hotspot password"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Turn off hotspot automatically"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"When no devices are connected"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Extend compatibility"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Helps other devices find this hotspot. Reduces hotspot connection speed."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Helps other devices find this hotspot. Increases battery usage."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Speed and compatibility"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2.4 GHz / Compatible with most devices"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Compatible with many devices"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Compatible with few devices"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2.4 and 5 GHz / Compatible with most devices"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Choose a frequency for your hotspot. The frequency affects the connection speed and what types of devices can find your hotspot."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Preferred frequency"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2.4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Slower speeds. Compatible with most devices."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Fast speeds. Compatible with many devices."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2.4 and 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Fast speeds. This dual-band hotspot is compatible with most devices."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Fastest speeds. Compatible with few devices."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Not available in your country or region"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"If your preferred frequency isn\'t available, your hotspot may use a different one. Hotspot security settings may change if you change the frequency."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Not available with 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Security settings may change if you change the hotspot’s frequency"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Instant hotspot"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"On"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Off"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Turning hotspot on…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Turning off hotspot…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Tethering unavailable"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Contact your operator for details"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> is active"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Android Hotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Save this network?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Saving…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Saved"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Can’t save. Try again."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Save networks?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Saving <xliff:g id="NUMBER">%d</xliff:g> networks…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Networks saved"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Wi-Fi Calling"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Extend calls with Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Turn on Wi‑Fi calling to extend coverage"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Calling preference"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Calling preference"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Roaming preference"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Roaming preference"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobile"</item>
    <item msgid="3027927219952052398">"Wi-Fi only"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mobile"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"If Wi‑Fi is unavailable, use mobile network"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"If mobile network is unavailable, use Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Call over Wi‑Fi. If Wi‑Fi is lost, call will end."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"When Wi-Fi calling is on, your phone can route calls via Wi-Fi networks or your mobile’s network, depending on your preference and which signal is stronger. Before turning on this feature, check with your operator regarding fees and other details.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Emergency address"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Used as your location when you make an emergency call over Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Learn more"</annotation>" about Private DNS features"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"On"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Activate Wi‑Fi Calling"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Turn on Wi‑Fi calling"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Disconnected from <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Sound and vibration"</string>
    <string name="account_settings" msgid="255404935489127404">"Accounts"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Work profile accounts - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Personal profile accounts"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Clone profile accounts"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Work account - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Personal account - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Search"</string>
    <string name="display_settings" msgid="7197750639709493852">"Display"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Auto-rotate screen"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Off"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"On"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"On – Face-based"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Face detection"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Learn more about auto-rotate"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Screen resolution"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"High resolution"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Full resolution"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Full resolution uses more of your battery. Switching your resolution may cause some apps to restart."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Selected"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Colours"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Natural"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Boosted"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Saturated"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptive"</string>
    <string name="brightness" msgid="6216871641021779698">"Brightness level"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Adaptive brightness"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Your screen brightness will automatically adjust to your environment and activities. You can move the slider manually to help adaptive brightness learn your preferences."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"On"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Off"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Display white balance"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Continue using apps on fold"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Disable default frame rate for games"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Disable limiting the maximum frame rate for games at <xliff:g id="FRAME_RATE">%1$d</xliff:g> Hz."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"Smooth display"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Automatically raises the refresh rate up to <xliff:g id="ID_1">%1$d</xliff:g> Hz for some content. Increases battery usage."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Force peak refresh rate"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Highest refresh rate for improved touch responsiveness and animation quality. Increases battery usage."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Screen attention"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Camera access needed"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Camera access is required for screen attention. Tap to manage permissions for Device Personalisation Services"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Manage permissions"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Prevents your screen from turning off if you’re looking at it"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Screen attention uses the front camera to see if someone is looking at the screen. It works on-device, and images are never stored or sent to Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Turn on screen attention"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Keep screen on when looking at it"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Longer screen timeout will use more battery."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Camera is locked"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Camera must be unlocked for face detection"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Camera must be unlocked for screen attention"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Camera access is required for face detection. Tap to manage permissions for Device Personalisation Services"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Manage permissions"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Night Light"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Night Light tints your screen amber. This makes it easier to look at your screen or read in dim light, and may help you fall asleep more easily."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Schedule"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"None"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Turns on at custom time"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Turns on from sunset to sunrise"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Start time"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"End time"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensity"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Will never turn on automatically"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Will turn on automatically at <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Will turn on automatically at sunset"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Will never turn off automatically"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Will turn off automatically at <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Will turn off automatically at sunrise"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Night Light not currently on"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Device location needed to determine your sunset and sunrise times."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Location settings"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Turn on now"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Turn off now"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Turn on until sunrise"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Turn off until sunset"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Dark mode"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Schedule"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"None"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Turns on from sunset to sunrise"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Turns on at custom time"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Turns on at bedtime"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Will never turn on automatically"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Will turn on automatically at sunset"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Will turn on automatically at <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Will turn on automatically at bedtime"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Will never turn off automatically"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Will turn off automatically at sunrise"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Will turn off automatically at <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Will turn off automatically after bedtime"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Dark theme uses a black background to help keep battery alive longer on some screens. Dark theme schedules wait to turn on until your screen is off."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Dark theme is currently following your Bedtime mode schedule"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Bedtime mode settings"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Screen timeout"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"After <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> of inactivity"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Not set"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Wallpaper"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Wallpaper and style"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Home, lock screen"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Change wallpaper"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalise your screen"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Choose wallpaper from"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Customise your phone"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Try different styles, wallpapers and more"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Screen saver"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"screensaver"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Unavailable because bedtime mode is on"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Use screen saver"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"While charging or docked"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"While docked and charging"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"While charging"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"While docked"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Never"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"On/<xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Off"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"When to start"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Lift to wake"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambient display"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"When to show"</string>
    <string name="doze_title" msgid="1523090408230862316">"Wake screen for notifications"</string>
    <string name="doze_summary" msgid="8252867381522942804">"When screen is dark, it turns on for new notifications"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Always show time and info"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Increased battery usage"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Bold text"</string>
    <string name="title_font_size" msgid="570613010306330622">"Font size"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Make text bigger or smaller"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"SIM lock settings"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"SIM lock"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Lock SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Change SIM PIN"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM PIN"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Lock SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Unlock SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Old SIM PIN"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"New SIM PIN"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Re‑type new PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM PIN"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Type a PIN that is 4 to 8 numbers"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PINs don\'t match"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM PIN changed successfully"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Can\'t disable PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Can\'t enable PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Cancel"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Use <xliff:g id="CARRIER">%1$s</xliff:g> for mobile data?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"You\'re using <xliff:g id="CARRIER2_0">%2$s</xliff:g> for mobile data. If you switch to <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> will no longer be used for mobile data."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Use <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Update preferred SIM?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> is the only SIM in your device. Do you want to use this SIM for mobile data, calls and SMS messages?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Improve mobile data coverage?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Allow your device to automatically switch to <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> for mobile data when it has better availability."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Calls, messages and network traffic may be visible to your organisation."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Incorrect SIM PIN code; you must now contact your operator to unlock your device."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Incorrect SIM PIN code; you have # remaining attempt before you must contact your operator to unlock your device.}other{Incorrect SIM PIN code; you have # remaining attempts.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Incorrect SIM PIN code; you have one remaining attempt before you must contact your operator to unlock your device."</string>
    <string name="pin_failed" msgid="3726505565797352255">"SIM PIN operation failed!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"System updates"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Android version"</string>
    <string name="security_patch" msgid="4071756145347865382">"Android security update"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Hardware version"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Manufactured year"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Equipment ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Baseband version"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Kernel version"</string>
    <string name="build_number" msgid="9009733242117579826">"Build number"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play system update"</string>
    <string name="battery_info" msgid="7873528123969546728">"Battery information"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Not available"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Storage"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Storage and cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Storage settings"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM slot <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (SIM slot <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (SIM slot <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primary)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"To view, choose saved network"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL version"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (SIM slot <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (SIM slot <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primary)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"On"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Off"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Mobile data network type"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Mobile voice network type"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Operator info"</string>
    <string name="status_data_state" msgid="525196229491743487">"Mobile network state"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Service state"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signal strength"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Network"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Wi‑Fi MAC address"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Device Wi‑Fi MAC address"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth address"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Serial number"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Uptime"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Manufacture date"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Date of first use"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Cycle count"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Unavailable"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Calculating..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Rename"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Mount"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Eject"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Format SD card for portable storage"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Format card"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Format as portable"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Format"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrate data"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Forget"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Set-up"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Free up space"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Manage storage"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Free up space"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Go to Files app to manage and free up space"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Other users"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> is mounted"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Couldn\'t mount <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> is safely ejected"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Couldn\'t safely eject <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Rename storage"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"This <xliff:g id="NAME_0">^1</xliff:g> is corrupted. \n\nTo use this <xliff:g id="NAME_1">^1</xliff:g>, you have to set it up first."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"You can format this SD card to store photos, videos, music and more and access them on other devices. \n\n"<b>"All data on this SD card will be erased."</b>" \n\n"<b>"Before formatting"</b>" \n\n"<b>"Back up photos &amp; other media"</b>" \nMove your media files to alternative storage on this device or transfer them to a computer using a USB cable. \n\n"<b>"Back up apps"</b>" \nAll apps stored on this <xliff:g id="NAME">^1</xliff:g> will be uninstalled and their data will be erased. To keep these apps, move them to alternative storage on this device."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"When you eject this <xliff:g id="NAME_0">^1</xliff:g>, apps stored on it will stop working, and media files stored on it will not be available until it is reinserted."</b>" \n\nThis <xliff:g id="NAME_1">^1</xliff:g> is formatted to work on this device only. It won’t work on any others."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"To use the apps, photos or data this <xliff:g id="NAME">^1</xliff:g> contains, reinsert it. \n\nAlternatively, you can choose to forget this storage if the device isn’t available. \n\nIf you choose to forget, all the data the device contains will be lost forever. \n\nYou can reinstall the apps later, but their data stored on this device will be lost."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Forget <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"All the apps, photos and data stored on this <xliff:g id="NAME">^1</xliff:g> will be lost forever."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"System includes files used to run Android version <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Guest mode users cannot format SD cards"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatting <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Don’t remove the <xliff:g id="NAME">^1</xliff:g> while it’s being formatted."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> formatted"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Move <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Moving <xliff:g id="APP">^1</xliff:g> and its data to <xliff:g id="NAME_0">^2</xliff:g> will take only a few moments. You won\'t be able to use the app until the move is complete. \n\nDon\'t remove the <xliff:g id="NAME_1">^2</xliff:g> during the move."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"To move data you need to unlock user <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Moving <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Don\'t remove the <xliff:g id="NAME">^1</xliff:g> during the move. \n\nThe <xliff:g id="APP">^2</xliff:g> app on this device won\'t be available until the move is complete."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"How will you use this <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Or"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Format SD card for portable storage"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Store photos, videos, music and more and access them from other devices. &lt;a href=https://support.google.com/android/answer/12153449&gt;Learn more about setting up an SD card&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Format"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Set up later"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Format this <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"This <xliff:g id="NAME_0">^1</xliff:g> needs to be formatted to store apps, files and media. \n\nFormatting will erase existing content on the <xliff:g id="NAME_1">^2</xliff:g>. To avoid losing content, back it up to another <xliff:g id="NAME_2">^3</xliff:g> or device."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"This <xliff:g id="NAME_0">^1</xliff:g> needs to be formatted to store photos, videos, music and more. \n\nFormatting will erase existing content on the <xliff:g id="NAME_1">^2</xliff:g>. To avoid losing content, back it up to another <xliff:g id="NAME_2">^3</xliff:g> or device."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Format <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Move content to <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"During the move:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Don’t remove the <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Some apps won’t work"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Move content"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Move content later"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Moving content…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Slow <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"You can still use this <xliff:g id="NAME_0">^1</xliff:g>, but it may be slow. \n\nApps stored on this <xliff:g id="NAME_1">^2</xliff:g> may not work properly, and content transfers could take a long time. \n\nTry using a faster <xliff:g id="NAME_2">^3</xliff:g>, or use this <xliff:g id="NAME_3">^4</xliff:g> for portable storage instead."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Start again"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Continue"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"You can start using your <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"You can start using your <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"You can start using your <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Battery status"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Battery level"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Communal"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Communal settings"</string>
    <!-- no translation found for satellite_setting (706846910912477125) -->
    <skip />
    <string name="apn_settings" msgid="4295467389400441299">"APNs"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Edit access point"</string>
    <string name="apn_add" msgid="9069613192201630934">"Add access point"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Not set"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Not set"</string>
    <string name="apn_name" msgid="6677695784108157953">"Name"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Username"</string>
    <string name="apn_password" msgid="7435086635953953029">"Password"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS proxy"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS port"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Authentication type"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN type"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN protocol"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"APN roaming protocol"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"APN enable/disable"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN enabled"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN disabled"</string>
    <string name="bearer" msgid="3231443241639159358">"Bearer"</string>
    <string name="network_type" msgid="748590707422733595">"Network type"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Unspecified"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO type"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO value"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Delete APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"New APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Save"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Cancel"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <!-- no translation found for error_duplicate_apn_entry (7792928408935276618) -->
    <skip />
    <string name="error_name_empty" msgid="1258275899283079142">"The Name field can\'t be empty."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"The APN cannot be empty."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC field must be 3 digits."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC field must be 2 or 3 digits."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operator does not allow adding APNs of type %s."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"MMSC field must be valid."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Restoring default APN settings."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Reset to default"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Reset default APN settings completed"</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Reset options"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Reset mobile network settings"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"This will reset all mobile network settings"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Reset mobile network settings?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Reset Bluetooth and Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"This will reset all Wi‑Fi &amp; Bluetooth settings. You can’t undo this action."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Reset"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth &amp; Wi‑Fi have been reset"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Erase eSIMs"</string>
    <!-- no translation found for reset_esim_desc (6125192435907740751) -->
    <skip />
    <string name="reset_network_button_text" msgid="2281476496459610071">"Reset settings"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Reset all network settings? You can\'t undo this action."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Reset all network settings and erase eSIMs? You can’t undo this action."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Reset settings"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Reset?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Network reset is not available for this user"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Network settings have been reset"</string>
    <!-- no translation found for reset_esim_error_title (6516110227665862295) -->
    <skip />
    <!-- no translation found for reset_esim_error_msg (8459527827897797168) -->
    <skip />
    <string name="main_clear_title" msgid="277664302144837723">"Erase all data (factory reset)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Erase all data (factory reset)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Music"</li>\n<li>"Photos"</li>\n<li>"Other user data"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIMs"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"This will not cancel your mobile service plan."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"All of your personal information and downloaded apps will be deleted. You can’t undo this action."</string>
    <!-- no translation found for main_clear_final_desc_esim (6592404057237813989) -->
    <skip />
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Erase all data?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Factory reset is not available for this user"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Erasing"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Please wait…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Call settings"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Set up voicemail, call forwarding, call waiting, caller ID"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB tethering"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Portable hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Bluetooth tethering"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Tethering"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot and tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot on, tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot on"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Tethering"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Can’t tether or use portable hotspots while Data Saver is on"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Hotspot only"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"USB only"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Bluetooth only"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Ethernet only"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Not sharing Internet with other devices"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Off"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB tethering"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Bluetooth tethering"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ethernet tethering"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Use hotspot and tethering to provide Internet to other devices through your mobile data connection. Apps can also create a hotspot to share content with nearby devices."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Use hotspot and tethering to provide Internet to other devices through your Wi‑Fi or mobile data connection. Apps can also create a hotspot to share content with nearby devices."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Help"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobile network"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS app"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Change SMS app?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Use <xliff:g id="NEW_APP">%1$s</xliff:g> instead of <xliff:g id="CURRENT_APP">%2$s</xliff:g> as your SMS app?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Use <xliff:g id="NEW_APP">%s</xliff:g> as your SMS app?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Change Wi‑Fi assistant?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Use <xliff:g id="NEW_APP">%1$s</xliff:g> instead of <xliff:g id="CURRENT_APP">%2$s</xliff:g> to manage your network connections?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Use <xliff:g id="NEW_APP">%s</xliff:g> to manage your network connections?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Recent location requests"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Location for work profile"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"App location permissions"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Location is off"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# of {total} apps has access to location}other{# of {total} apps have access to location}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Recent access"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"See all"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"View details"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"No apps have requested location recently"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"No apps recently accessed location"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"High battery use"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Low battery use"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Wi‑Fi scanning"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Allow apps and services to scan for Wi‑Fi networks at any time, even when Wi‑Fi is off. This can be used, for example, to improve location-based features and services."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth scanning"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Allow apps and services to scan for nearby devices at any time, even when Bluetooth is off. This can be used, for example, to improve location-based features and services."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Location Services"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Location Services"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Use location"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Cannot set the time zone automatically"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Location or Location Services are off"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Device location needed"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"To set the time zone using your location, turn on location, then update time zone settings"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Location settings"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Fix this"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Cancel"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatic time zone is off"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Location time zone detection is disabled"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Location time zone detection is not supported"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Location time zone detection changes are not allowed"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Location may be used to set time zone"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"View legal info, status, software version"</string>
    <string name="legal_information" msgid="7509900979811934843">"Legal information"</string>
    <string name="manual" msgid="3651593989906084868">"Manual"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulatory labels"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Safety and regulatory manual"</string>
    <string name="copyright_title" msgid="83245306827757857">"Copyright"</string>
    <string name="license_title" msgid="8745742085916617540">"Licence"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Google Play system update licences"</string>
    <string name="terms_title" msgid="2071742973672326073">"Terms and conditions"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"System WebView Licence"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Wallpaper credits"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Satellite imagery providers:\n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Manual"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"There is a problem loading the manual."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Third-party licences"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"There is a problem loading the licences."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Loading…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Loading…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Set a password"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Set a work password"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Set a PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Set a work PIN"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Set a pattern"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"For added security, set a pattern to unlock the device"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Set a work pattern"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"To use fingerprint, set password"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"To use fingerprint, set pattern"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"For security, set PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"To use fingerprint, set PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Re-enter your password"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Re-enter your work password"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Enter your work password"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Confirm your pattern"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Enter your work pattern"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Re-enter your PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Re-enter your work PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Enter your work PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Passwords don\'t match"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PINs don\'t match"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Draw your pattern again"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Unlock selection"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"password has been set"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN has been set"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Pattern has been set"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"To use Face Unlock, set password"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"To use Face Unlock, set pattern"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"To use Face Unlock, set PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Set a password to use face or fingerprint"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Set a pattern to use face or fingerprint"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Set a PIN to use face or fingerprint"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Forgot your password?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Forgot your pattern?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Forgotten your PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Draw your pattern to continue"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Enter your PIN to continue"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Enter your password to continue"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Draw your work pattern to continue"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Enter your work PIN to continue"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Enter your work password to continue"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"For added security, use your device pattern"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"For added security, enter your device PIN"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"For added security, enter your device password"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"For added security, use your work pattern"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"For added security, enter your work PIN"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"For added security, enter your work password"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verify pattern"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verify PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verify password"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Verify that it\'s you"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"To transfer Google Accounts, settings and more, enter your other device\'s pattern. Your pattern is encrypted."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"To transfer Google Accounts, settings and more, enter your other device\'s PIN. Your PIN is encrypted."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"To transfer Google Accounts, settings and more, enter your other device\'s password. Your password is encrypted."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Also use pattern to unlock this device"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Also use PIN to unlock this device"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Also use password to unlock this device"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Verify pattern"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Verify PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Verify password"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Use your device pattern to continue"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Enter your device PIN to continue"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Enter your device password to continue"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Wrong PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Wrong password"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Wrong pattern"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Emergency"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Device security"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Change unlock pattern"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Change unlock PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Draw an unlock pattern"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Press Menu for help."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Release finger when done"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Connect at least <xliff:g id="NUMBER">%d</xliff:g> dots. Try again."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Pattern recorded"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Draw pattern again to confirm"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Your new unlock pattern"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Confirm"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Redraw"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Clear"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Continue"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Unlock pattern"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Require pattern"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Must draw pattern to unlock screen"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Make pattern visible"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Enhanced PIN privacy"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Disable animations while entering the PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Make profile pattern visible"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrate on tap"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Power button instantly locks"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Except when kept unlocked by <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Set unlock pattern"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Change unlock pattern"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"How to draw an unlock pattern"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Too many incorrect attempts. Try again in <xliff:g id="NUMBER">%d</xliff:g> seconds."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Application is not installed on your phone."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Work profile security"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Work profile screen lock"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Use one lock"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Use one lock for work profile and device screen"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Use one lock?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Your device will use your work profile screen lock. Work policies will apply to both locks."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Your work profile lock doesn\'t meet your organisation\'s security requirements. You can use the same lock for your device screen and your work profile, but any work lock policies will apply."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Use one lock"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Use one lock"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Same as device screen lock"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Manage apps"</string>
    <string name="applications_settings" msgid="1941993743933425622">"App info"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"App settings"</string>
    <string name="install_applications" msgid="3921609656584369901">"Unknown sources"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Allow all app sources"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Recently opened apps"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{See all apps}other{See all # apps}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Contact your IT admin"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"They can help you reset your PIN, pattern or password"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Advanced settings"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Enable more settings options"</string>
    <string name="application_info_label" msgid="1015706497694165866">"App info"</string>
    <string name="storage_label" msgid="2522307545547515733">"Storage"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Open by default"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Defaults"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Screen compatibility"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Permissions"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Cache"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Clear cache"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Cache"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 item}other{# items}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Clear access"</string>
    <string name="controls_label" msgid="8671492254263626383">"Controls"</string>
    <string name="force_stop" msgid="2681771622136916280">"Force stop"</string>
    <string name="archive" msgid="9074663845068632127">"Archive"</string>
    <string name="restore" msgid="7622486640713967157">"Restore"</string>
    <!-- no translation found for restoring_step_one (3465050101254272874) -->
    <skip />
    <!-- no translation found for restoring_step_two (140484846432595108) -->
    <skip />
    <!-- no translation found for restoring_step_three (3712883580876329811) -->
    <skip />
    <!-- no translation found for restoring_step_four (8966846882470446209) -->
    <skip />
    <string name="total_size_label" msgid="2052185048749658866">"Total"</string>
    <string name="application_size_label" msgid="6407051020651716729">"App size"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"USB storage app"</string>
    <string name="data_size_label" msgid="7814478940141255234">"User data"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Uninstall"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Uninstall for all users"</string>
    <string name="install_text" msgid="4558333621516996473">"Install"</string>
    <string name="disable_text" msgid="5146002260857428005">"Disable"</string>
    <string name="enable_text" msgid="8570798764647110430">"Enable"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Clear storage"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Uninstall updates"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Allow restricted settings"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Some activities that you’ve selected open in this app by default."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"You\'ve chosen to allow this app to create widgets and access their data."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"No defaults set."</string>
    <string name="clear_activities" msgid="488089228657585700">"Clear default preferences"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"This app may not be designed for your screen. You can control how it adjusts to your screen here."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Ask when launched"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Scale app"</string>
    <string name="unknown" msgid="8192160131923461175">"Unknown"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sort by name"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sort by size"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Most recent"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Most frequent"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Show running services"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Show cached processes"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Emergency app"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Reset app preferences"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Reset app preferences?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"This will reset all preferences for:\n\n"<li>"Disabled apps"</li>\n<li>"Disabled app notifications"</li>\n<li>"Default applications for actions"</li>\n<li>"Background data restrictions for apps"</li>\n<li>"Any permission restrictions"</li>\n<li>"Battery usage settings"</li>\n\n"You will not lose any app data."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Reset apps"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Choose filter options"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"All apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Disabled apps"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Downloaded"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Running"</string>
    <string name="not_installed" msgid="5074606858798519449">"Not installed for this user"</string>
    <string name="installed" msgid="2837449358488825884">"Installed"</string>
    <string name="no_applications" msgid="985069304755391640">"No apps."</string>
    <string name="internal_storage" msgid="999496851424448809">"Internal storage"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Recomputing size…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Delete app data?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"This app’s data, including files and settings, will be permanently deleted from this device"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Cancel"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Delete"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"The app wasn\'t found in the list of installed apps."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Couldn’t clear storage for app."</string>
    <string name="computing_size" msgid="4915310659841174866">"Computing…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Couldn\'t compute the package size."</string>
    <string name="version_text" msgid="7628938665256107608">"Version <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Move"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Archiving failed"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"Archived <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Restoring failed"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Restoring <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Another migration is already in progress."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Not enough storage space."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"App doesn\'t exist."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Install location isn\'t valid."</string>
    <string name="system_package" msgid="7559476279008519360">"System updates cannot be installed on external media."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Device admin app can\'t be installed on external media"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Force stop?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"If you force-stop an app, it may misbehave."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Disable app"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"If you disable this app, Android and other apps may no longer function as intended. Keep in mind, you can’t delete this app since it came pre-installed on your device. By disabling, you turn this app off and hide it on your device."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Store"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"App details"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"App installed from <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"More info on <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Running"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Never used)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Storage use"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Restarting"</string>
    <string name="cached" msgid="5379485147573438201">"Cached background process"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nothing running."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Started by app."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> free"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> used"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"User: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Removed user"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> process and <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> process and <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processes and <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processes and <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Device memory"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"App RAM usage"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"System"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Apps"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Free"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Used"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Cached"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> of RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Running app"</string>
    <string name="no_services" msgid="3898812785511572899">"Not active"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Services"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Processes"</string>
    <string name="service_stop" msgid="5712522600201308795">"Stop"</string>
    <string name="service_manage" msgid="3896322986828332075">"Settings"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"This service was started by its app. Stopping it may cause the app to fail."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"This app can\'t be stopped safely. If you stop it, you may lose some of your current work."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"This is an old app process that is still running in case it\'s needed again. There is usually no reason to stop it."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: currently in use. Tap Settings to control it."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Main process in use."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Service <xliff:g id="COMP_NAME">%1$s</xliff:g> is in use."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Provider <xliff:g id="COMP_NAME">%1$s</xliff:g> is in use."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Stop system service?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Languages, input &amp; gestures"</string>
    <string name="language_settings" msgid="8700174277543875046">"Languages and input"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Languages"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Keyboard"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"You don’t have permission to change the device language."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Languages and input"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Tools"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Keyboard &amp; input methods"</string>
    <string name="system_language" msgid="1146762166579643257">"System languages"</string>
    <string name="phone_language" msgid="5986939176239963826">"Languages"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Auto-replace"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Correct mistyped words"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Auto-capitalisation"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Capitalise first letter in sentences"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Auto-punctuate"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Physical keyboard settings"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Press Space key twice to insert \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Show passwords"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Display characters briefly as you type"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"This spell checker may be able to collect all the text that you type, including personal data like passwords and credit card numbers. It comes from the app <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Use this spell checker?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Settings"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Language"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Keyboards"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"On-screen keyboard"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Available on-screen keyboard"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Manage on-screen keyboards"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Options"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Accessibility"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Physical keyboard"</string>
    <string name="show_ime" msgid="4334255501724746849">"Use on-screen keyboard"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Keep it on screen while physical keyboard is active"</string>
    <string name="bounce_keys" msgid="7419450970351743904">"Bounce keys"</string>
    <string name="bounce_keys_summary" msgid="6922850403920596246">"Enable bounce keys for physical keyboard accessibility"</string>
    <string name="sticky_keys" msgid="7317317044898161747">"Sticky keys"</string>
    <string name="sticky_keys_summary" msgid="8520909829540989765">"Enable sticky keys for physical keyboard accessibility"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Keyboard shortcuts"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Show list of shortcuts"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Work profile keyboards &amp; tools"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"On-screen keyboard for work"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Default"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad &amp; mouse"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Pointer speed, gestures"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Tap to click"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Touchpad gestures"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Customise individual touchpad navigation gestures"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Reverse scrolling"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Content moves up when you scroll down"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Bottom-right tap"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Tap the bottom-right corner of the touchpad for more options"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Pointer speed"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Learn touchpad gestures"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Go home"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Swipe up with three fingers anywhere on your touchpad"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Go back"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Swipe from the left or right with three fingers"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"View recent apps"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Swipe up with three fingers, hold, then release"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"View notifications &amp; Quick Settings"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Swipe down with three fingers on your home screen"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Switch apps"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Swipe left or right with four fingers"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Skip"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Next"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Restart"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Done"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Go back"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Swipe left or right with three fingers"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Go home"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Swipe up with three fingers"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Recent apps"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Swipe up with three fingers, then hold"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Notifications"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Swipe down with three fingers"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Switch apps"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Swipe left or right with four fingers"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifier keys"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Change the behaviour of keys"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Reset all"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Default"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Are you sure that you would like to reset all the modifier keys to their default?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Done"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Cancel"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Reset"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choose modifier key"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choose a new key for <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Speech"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Pointer speed"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Game Controller"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Redirect vibration"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Send vibration to game controller when connected"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Choose keyboard layout"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Set up keyboard layouts"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"To switch, press Control-Spacebar"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Default"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Keyboard layouts"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Physical keyboard layouts"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Personal dictionary"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Personal dictionary for work"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Add words to be used in apps such as spell checker"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Add"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Add to dictionary"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Phrase"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"More options"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Fewer options"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Word:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Shortcut:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Language:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Type a word"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Optional shortcut"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Edit word"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Edit"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Delete"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"You don’t have any words in the user dictionary. To add a word, tap the Add (+) button."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"For all languages"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"More languages…"</string>
    <string name="testing" msgid="6294172343766732037">"Testing"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"On-screen keyboard, tools"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"On-screen keyboard, physical keyboard, tools"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Physical keyboard"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Layout"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Choose gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Choose widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Create widget and allow access?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"After you create the widget, the application can access everything displayed.\n\nApplication: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Always allow <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> to create widgets and access their data"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Usage statistics"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Sort by usage time"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Sort by last time used"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Sort by app name"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Last used"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"never"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Usage time"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Accessibility"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Accessibility settings"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Display, interaction, audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Vision settings"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"You can customise this device to fit your needs. These accessibility features can be changed later in Settings."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Change font size"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Screen reader"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Captions"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"General"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Display"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Colour and motion"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Turn screen darker"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaction controls"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Timing controls"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"System controls"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Downloaded apps"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimental"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Feature flags"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Bluetooth HCI snoop log filtering"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Set filters"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Disable and enable Bluetooth for the changes to take effect"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Bluetooth HCI snoop log filtering PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Bluetooth HCI snoop log filtering MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Set filtering mode. (Disable and enable Bluetooth for the changes to take effect)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Set Bluetooth HCI snoop log mode to Enabled Filtered to change this option"</string>
    <string name="talkback_title" msgid="8756080454514251327">"Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Screen reader primarily for people with blindness and low vision"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Tap items on your screen to hear them read aloud"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Caption preferences"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"About caption preferences"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Learn more about caption preferences"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Magnification"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Magnification shortcut"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Magnify typing"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Magnifier follows text as you type"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Keep on while switching apps"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Magnifier stays on and zooms out when you switch apps"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Activate and move the magnifier with an on-screen joystick. Tap and hold, then drag on the joystick to control the magnifier. Tap and drag to move the joystick itself."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"About magnification"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Learn more about magnification"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Magnification type"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Magnify your full screen, a specific area, or switch between both options"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Full screen"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Partial screen"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Switch between full and partial screen"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Choose how to magnify"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Magnify full screen"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Magnify part of screen"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Switch between full and partial screen"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Tap the switch button to move between both options"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Switch to accessibility button?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Using triple-tap to magnify part of your screen causes typing and other delays.\n\nThe Accessibility button floats on your screen over other apps. Tap it to magnify."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Switch to accessibility button"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Use triple-tap"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"This may slow down your keyboard"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"When using triple-tap to magnify part of your screen, you may notice issues over the keyboard.\n\nTo avoid this, you can change your magnification shortcut from triple-tap to another option.\n"<annotation id="link">"Change setting"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continue anyway"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancel"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Magnification settings"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Magnify with shortcut"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Magnify with shortcut &amp; triple-tap"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"About <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Display size and text"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Change how text displays"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Subject: Hot air balloon designs"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"From: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Good morning!\n\nI just wanted to check how the designs are coming. Will they be ready before we start building the new balloons?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Reset settings"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Display size and text settings have been reset"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Reset display size and text?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Reset"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Any weekend plans?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Heading to the beach. Want to join?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Options"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Zoom in on screen"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Tap 3 times to zoom"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Tap a button to zoom"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Quickly zoom in on the screen to make content larger"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;To zoom in:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Use shortcut to start magnification&lt;br/&gt; {1,number,integer}. Tap the screen&lt;br/&gt; {2,number,integer}. Drag two fingers to move around screen&lt;br/&gt; {3,number,integer}. Pinch with two fingers to adjust zoom&lt;br/&gt; {4,number,integer}. Use shortcut to stop magnification&lt;br/&gt;&lt;br/&gt; &lt;b&gt;To zoom in temporarily:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Make sure that your magnification type is set to full screen&lt;br/&gt; {1,number,integer}. Use shortcut to start magnification&lt;br/&gt; {2,number,integer}. Touch and hold anywhere on the screen&lt;br/&gt; {3,number,integer}. Drag finger to move around screen&lt;br/&gt; {4,number,integer}. Lift finger to stop magnification"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"When magnification is turned on, you can zoom in on your screen.\n\n"<b>"To zoom"</b>", start magnification, then tap anywhere on the screen.\n"<ul><li>"Drag 2 or more fingers to scroll"</li>\n<li>"Pinch 2 or more fingers to adjust zoom"</li></ul>\n\n<b>"To zoom temporarily"</b>", start magnification, then touch and hold anywhere on the screen.\n"<ul><li>"Drag to move around the screen"</li>\n<li>"Lift finger to zoom out"</li></ul>\n\n"You can’t zoom in on the keyboard or navigation bar."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Page <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> of <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Use Accessibility button to open"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Hold volume keys to open"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Triple-tap screen to open"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Two-finger double-tap screen to open"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Use gesture to open"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Use accessibility gesture"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"To use this feature, tap the accessibility button <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> on the bottom of your screen.\n\nTo switch between features, touch and hold the accessibility button."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"To use this feature, tap the Accessibility button on your screen."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"To use this feature, press and hold both volume keys."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"To start and stop magnification, triple-tap anywhere on your screen."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"To start and stop magnification, double-tap anywhere on your screen with two fingers."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"To use this feature, swipe up from the bottom of the screen with two fingers.\n\nTo switch between features, swipe up with two fingers and hold."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"To use this feature, swipe up from the bottom of the screen with three fingers.\n\nTo switch between features, swipe up with three fingers and hold."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"To use an accessibility feature, swipe up from the bottom of the screen with two fingers.\n\nTo switch between features, swipe up with two fingers and hold."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"To use an accessibility feature, swipe up from the bottom of the screen with three fingers.\n\nTo switch between features, swipe up with three fingers and hold."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"OK"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Button settings"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"<xliff:g id="SERVICE">%1$s</xliff:g> shortcut"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Accessibility button"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Accessibility gesture"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Swipe up with 2 fingers"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Swipe up with three fingers"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Tap Accessibility button"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Use accessibility gesture"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Tap the accessibility button <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> at the bottom of your screen.\n\nTo switch between features, touch and hold the accessibility button."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Swipe up from the bottom of the screen with 2 fingers.\n\nTo switch between features, swipe up with 2 fingers and hold."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Swipe up from the bottom of the screen with three fingers.\n\nTo switch between features, swipe up with three fingers and hold."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"More options"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Learn more about <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Hold volume keys"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"hold volume keys"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Press and hold both volume keys"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Two-finger double-tap screen"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"Two-finger double-tap screen"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Quickly tap screen {0,number,integer} times with two fingers"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Triple-tap screen"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"triple-tap screen"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Quickly tap screen {0,number,integer} times. This shortcut may slow down your device"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Advanced"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"The accessibility button is set to <xliff:g id="SERVICE">%1$s</xliff:g>. To use magnification, touch &amp; hold the accessibility button, then select magnification."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"The accessibility gesture is set to the <xliff:g id="SERVICE">%1$s</xliff:g>. To use magnification, swipe up with two fingers from the bottom of the screen and hold. Then select magnification."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Volume key shortcut"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Shortcut settings"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Shortcut from lock screen"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Allow feature shortcut to turn on from the lock screen. Hold both volume keys for a few seconds."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Accessibility button"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Accessibility button &amp; gesture"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Quickly access accessibility features from any screen"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"About accessibility button"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"About accessibility button &amp; gesture"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Learn more about accessibility button &amp; gesture"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Using the accessibility button. The gesture isn’t available with 3-button navigation."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Quickly access accessibility features"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;To get started&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Go to accessibility settings&lt;br/&gt; {1,number,integer}. Select a feature and tap the shortcut&lt;br/&gt; {2,number,integer}. Choose whether you want to use a button or gesture to access the feature&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;To get started&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Go to accessibility settings&lt;br/&gt; {1,number,integer}. Select a feature and tap the shortcut&lt;br/&gt; {2,number,integer}. Choose the button to access the feature&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Use button or gesture"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Location"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Size"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Fade when not in use"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Fades after a few seconds so it’s easier to see your screen"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparency when not in use"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparent"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Non-transparent"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"High-contrast text"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Change text colour to black or white. Maximises contrast with the background."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Auto update screen magnification"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Update screen magnification on app transitions"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Power button ends call"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Large mouse cursor"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Make the mouse pointer more noticeable"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Make all apps dark"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Applies to apps without their own Dark theme. Some apps may have display issues, like inverted colours."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Remove animations"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Reduce movement on the screen"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Mono audio"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Combine channels when playing audio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Audio balance"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Left"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Right"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Default"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 seconds"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 seconds"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minute"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutes"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Time to take action (Accessibility timeout)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"About time to take action (accessibility timeout)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Learn more about time to take action (accessibility timeout)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Time to take action"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"This timing preference isn’t supported by all apps"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Choose how long to show temporary messages that ask you to take action"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Touch and hold delay"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Colour inversion"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Use colour inversion"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Colour inversion shortcut"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Colour inversion turns light screens dark. It also turns dark screens light."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Keep in mind&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Colours will change in media and images&lt;/li&gt; &lt;li&gt; Colour inversion works on all apps&lt;/li&gt; &lt;li&gt; To display a dark background, Dark theme can be used instead&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"enter settings"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Autoclick (dwell timing)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"About auto-click (dwell timing)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Learn more about autoclick (dwell timing)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"You can set a connected mouse to click automatically when the cursor stops moving for a certain amount of time"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Autoclick can be helpful if clicking the mouse is difficult"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Auto-click off"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Short"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0.2 seconds"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Medium"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0.6 seconds"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Long"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 second"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Custom"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Shorter"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Longer"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Auto click time"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibration and haptics"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Control the vibration strength for different usages"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"On"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Off"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Setting disabled because device is set to silent"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Calls"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Notifications and alarms"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interactive haptics"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Use vibration and haptics"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Alarm vibration"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Media vibration"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Keyboard vibration"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Ring vibration"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Notification vibration"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Touch feedback"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Use <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Open <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> added to Quick Settings. Swipe down to turn it on or off at any time."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"You can also add <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> to Quick Settings from the top of your screen"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Colour correction added to Quick Settings. Swipe down to turn it on or off at any time."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"You can also add colour correction to Quick Settings from the top of your screen"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Colour inversion added to Quick Settings. Swipe down to turn it on or off at any time."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"You can also add colour inversion to Quick Settings from the top of your screen"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Extra dim added to Quick Settings. Swipe down to turn it on or off at any time."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"You can also add extra dim to Quick Settings from the top of your screen"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"One-handed mode added to Quick Settings. Swipe down to turn it on or off at any time."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"You can also add one-handed mode to Quick Settings from the top of your screen"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Font size added to Quick Settings. Swipe down to change the font size at any time."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Dismiss"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Use colour correction"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Colour correction shortcut"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"About colour correction"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Learn more about colour correction"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"About colour inversion"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Learn more about colour inversion"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Show captions"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"For supported app only"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Caption size and style"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"<xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g> text size"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"More options"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Customise caption size and style to make them easier to read"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"These caption preferences aren’t supported by all media apps"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Accessibility button"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"2-finger swipe up from bottom"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold volume keys"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triple-tap screen"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continue"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hearing devices"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"You can use hearing aids, cochlear implants and other amplification devices with your phone"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hearing devices connected"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Add hearing aids"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Pair hearing aids"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"On the next screen, tap on your hearing aids. You may need to pair the left and right ears separately.\n\nMake sure that your hearing aids are turned on and ready to pair."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> active"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, left only"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, right only"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, left and right"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> +1 more"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Pair new device"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"About pair new device"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Hearing devices"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Saved devices"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Hearing device controls"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Hearing device shortcut"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Hearing aid compatibility"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Improves compatibility with telecoils and reduces unwanted noise"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"About hearing devices"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Make sure that your hearing device is turned on and ready to pair"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Pair hearing device"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Available hearing devices"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Don’t see your hearing device?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"See more devices"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Audio adjustment"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audio description"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Hear a description of what’s happening on screen in supported movies and shows"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"audio description, audio, description, low vision,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Shortcut on"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Off"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"On"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Off"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Not working. Tap for info."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"This service is malfunctioning."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Accessibility shortcuts"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Show in Quick Settings"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Red-green"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Red-green"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Blue-yellow"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Greyscale"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Green weak, deuteranomaly"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Red weak, protanomaly"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomaly"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Extra dim"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Make screen extra dim"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Extra dim shortcut"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"About extra dim"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Make your screen dimmer so that it’s more comfortable to read"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensity"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Dimmer"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Brighter"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Keep on after device restarts"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Short ({time} second)}other{Short ({time} seconds)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Medium ({time} second)}other{Medium ({time} seconds)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Long ({time} second)}other{Long ({time} seconds)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} second}other{{time} seconds}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Settings"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"On"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Off"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Preview"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standard options"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Language"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Text size"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Caption style"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Customisation options"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Background colour"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Background opacity"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Caption window colour"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Caption window opacity"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Text colour"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Text opacity"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Edge colour"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Edge type"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Font family"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Captions will look like this"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Default"</string>
    <string name="color_title" msgid="2511586788643787427">"Colour"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Default"</string>
    <string name="color_none" msgid="3703632796520710651">"None"</string>
    <string name="color_white" msgid="1896703263492828323">"White"</string>
    <string name="color_gray" msgid="8554077329905747877">"Grey"</string>
    <string name="color_black" msgid="9006830401670410387">"Black"</string>
    <string name="color_red" msgid="5210756997426500693">"Red"</string>
    <string name="color_green" msgid="4400462091250882271">"Green"</string>
    <string name="color_blue" msgid="4997784644979140261">"Blue"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cyan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Yellow"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Allow <xliff:g id="SERVICE">%1$s</xliff:g> to have full control of your device?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> needs to:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Because an app is obscuring a permission request, Settings can’t verify your response."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> is requesting full control of this device. The service can read the screen and act on behalf of users with accessibility needs. This level of control is not appropriate for most apps."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Full control is appropriate for apps that help you with accessibility needs, but not for most apps."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"View and control screen"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"It can read all content on the screen and display content over other apps."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"View and perform actions"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"It can track your interactions with an app or a hardware sensor, and interact with apps on your behalf."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Allow"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Deny"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Turn off"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Keep on"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Turn off <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"No services installed"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"No service selected"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"No description provided."</string>
    <string name="settings_button" msgid="2195468788019730377">"Settings"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"light sensitivity, photophobia, dark theme, migraine, headache, reading mode, night mode, reduce brightness, white point"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"vision, hearing, blind, deaf, motor, dexterity, assistive, assistance, ease of use, ease of access, hand, help"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Window magnifier, zoom, magnification, low vision, enlarge, make bigger"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Captions, closed captions, CC, Live Transcribe, hard of hearing, hearing loss, CART, speech to text, subtitle"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"screen size, large screen"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"High contrast, low vision, bold font, bold face"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"adjust colour"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"turn screen dark, turn screen light"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"colour contrast"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"motor, mouse, external mouse, head mouse, adaptive mouse, wheelchair, joystick"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"hearing aids, hard of hearing, hearing loss, cochlear implants, amplification devices, sound processors, PSAP"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"hard of hearing, hearing loss, captions, Teletype, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"three buttons"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"dexterity, motor, senior, arthritis, rsi, stroke, tremor, multiple sclerosis, cerebral palsy, shaking, repetitive strain injury, hand"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"delay, dexterity, senior"</string>
    <string name="print_settings" msgid="8519810615863882491">"Printing"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Off"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 print service on}other{# print services on}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 print job}other{# print jobs}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Print services"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"No services installed"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"No printers found"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Settings"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Add printers"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"On"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Off"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Add service"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Add printer"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Search"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Searching for printers"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Service disabled"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Print jobs"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Print job"</string>
    <string name="print_restart" msgid="4424096106141083945">"Restart"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Cancel"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Configuring <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Printing <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Cancelling <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Printer error <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printer blocked <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Search box shown"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Search box hidden"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"More information about this printer"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Battery"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"What has been using the battery"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"<xliff:g id="REMAIN">%1$s</xliff:g> remaining"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> to charge"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Screen time"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Background time"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Low battery"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Allow the app to run in the background"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Limit background activity?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"If you limit background activity for an app, it may misbehave"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Since this app is not set to optimise battery, you can’t restrict it.\n\nTo restrict the app, first turn on battery optimisation."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Manage battery usage"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Allow background usage"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Enable for real-time updates, disable to save battery"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Unrestricted"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimised"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Restricted"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Allow battery usage in background without restrictions. May use more battery."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimise based on your usage. Recommended for most apps."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Restrict battery usage while in background. App may not work as expected. Notifications may be delayed."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Changing how an app uses your battery can affect its performance."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"This app requires <xliff:g id="STATE">%1$s</xliff:g> battery usage."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"unrestricted"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimised"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Learn more about battery usage options"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Screen usage since full charge"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Battery usage"</string>
    <string name="history_details_title" msgid="8628584613889559355">"History details"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Battery usage"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"View usage for past 24 hours"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"View usage since last full charge"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"App battery usage"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Use details"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Adjust power use"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Included packages"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Apps are running normally"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Battery level low"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Turn on Battery Saver to extend battery life"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Improve battery life"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Turn on Battery Manager"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Turn on Battery Saver"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Battery may run out earlier than usual"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Battery Saver on"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Learn more about Battery Saver"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Some features may be limited"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Higher battery usage"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"See apps with highest usage"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Charging optimised to protect your battery"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"To help extend your battery\'s lifespan, charging is optimised"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Learn more about charging is paused"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Resume charging"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Includes high-power background activity"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Restrict # app}other{Restrict # apps}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} recently restricted}other{# apps recently restricted}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} has high background battery usage}other{# apps have high background battery usage}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{This app can\'t run in the background}other{These apps can\'t run in the background}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Restrict app?}other{Restrict # apps?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"To save battery, stop <xliff:g id="APP">%1$s</xliff:g> from using battery in the background. This app may not work properly and notifications may be delayed."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"To save battery, stop these apps from using battery in the background. Restricted apps may not work properly and notifications may be delayed.\n\nApps:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"To save battery, stop these apps from using battery in the background. Restricted apps may not work properly and notifications may be delayed.\n\nApps:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Restrict"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Remove restriction?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"This app will be able to use battery in the background. Your battery may run out sooner than expected."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Remove"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Cancel"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Charge to full"</string>
    <!-- no translation found for battery_tip_incompatible_charging_title (1567827436103364999) -->
    <skip />
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Learn more about incompatible charging"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Battery Manager"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Manage apps automatically"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"When Battery Manager detects that apps are draining battery, you’ll have the option to restrict these apps. Restricted apps may not work properly and notifications may be delayed."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Restricted apps"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Limiting battery usage for # app}other{Limiting battery usage for # apps}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Restricted <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"These apps are restricted from background battery usage. They may not work as expected, and notifications may be delayed."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Use Battery Manager"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Detect when apps drain battery"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Detecting when apps drain battery"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Detecting when apps drain battery"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# app restricted}other{# apps restricted}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Problem reading the battery meter."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Tap to find out more about this error"</string>
    <string name="power_screen" msgid="4596900105850963806">"Screen"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Flashlight"</string>
    <string name="power_camera" msgid="4778315081581293923">"Camera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobile network"</string>
    <string name="power_phone" msgid="2768396619208561670">"Voice calls"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Screen usage <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> used by <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> of overall battery"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Breakdown since last full charge"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Last full charge"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Full charge lasts about"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Remaining battery life is approximate and may change based on usage"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Battery usage"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"No usage since last full charge"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"No usage for past 24 hr"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"since last full charge"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"System apps"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Uninstalled apps"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Others"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Estimated time left"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Until fully charged"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Estimate may change based on usage"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Media server"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"App optimisation"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Tethering"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Removed apps"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Battery Saver"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Turn on automatically"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"No schedule"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Based on your routine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Will turn on based on your routine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Based on percentage"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Battery Saver turns on if your battery is likely to run out before your next typical charge"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Will turn on at <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Set a schedule"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Extend battery life"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Turn off when charged"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Turn off at <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Battery Saver turns off when battery reaches <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Turn on"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Use Battery Saver"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Turn on automatically"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Never"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"at <xliff:g id="PERCENT">%1$s</xliff:g> battery"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Battery percentage"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Show battery percentage in status bar"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Battery level since last full charge"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Battery level for the past 24 hours"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"App usage since last full charge"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"App usage for the past 24 hours"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"System usage since last full charge"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"System usage for past 24 hours"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"System usage for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"App usage for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"System usage since last full charge to <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"App usage since last full charge to <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Total: less than a min."</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Background: less than a min"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Screen time: less than a min"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Less than a min"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Total: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Background: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Screen time: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Battery usage data will be available in a few hours once fully charged"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"now"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> – <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_time_info_and_battery_level" msgid="6732629268310936155">"<xliff:g id="TIME_INFO">%1$s</xliff:g> <xliff:g id="BATTERY_LEVEL">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Battery usage chart"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Daily battery usage chart"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Hourly battery usage chart"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Battery level percentage from <xliff:g id="START_PERCENTAGE">%1$s</xliff:g> to <xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Battery usage since last full charge"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Battery usage for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Screen time since last full charge"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Screen time for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"View by apps"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"View by systems"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Due to quality inspections before delivery, the cycle count may not be zero on first use"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Process Stats"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Geeky stats about running processes"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Memory use"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> of <xliff:g id="TOTALRAM">%2$s</xliff:g> used over last <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> of RAM used over <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Background"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Foreground"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Cached"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Native"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Caches"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM use"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM use (background)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Running time"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Processes"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Services"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Duration"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Memory details"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 hours"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 hours"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 hours"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 day"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Show system"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Hide system"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Show percentages"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Use Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Stats type"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Background"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Foreground"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Cached"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Voice input &amp; output"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Voice input &amp; output settings"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Voice search"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android keyboard"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Voice input settings"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Voice input"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Voice input services"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Full hotword and interaction"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Simple speech to text"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"This voice input service will be able to perform always-on voice monitoring, and control voice enabled applications on your behalf. It comes from the <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g> application. Enable the use of this service?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"On-device recognition settings"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"On-device recognition"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"On-device speech recognition"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Preferred engine"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Engine settings"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Speech rate &amp; pitch"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Engine"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Voices"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Spoken Language"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Install Voices"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Continue to the <xliff:g id="TTS_APP_NAME">%s</xliff:g> app to install voices"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Open App"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Cancel"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Reset"</string>
    <string name="tts_play" msgid="2945513377250757221">"Play"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Not secure"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> not secure"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> not secure"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Adaptive connectivity"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Extends battery life and improves device performance by automatically managing your network connections"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"On"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Off"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Use adaptive connectivity"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Credential storage"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Install a certificate"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Clear credentials"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Remove all certificates"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Trusted credentials"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Display trusted CA certificates"</string>
    <string name="user_credentials" msgid="4044405430790970775">"User credentials"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"View and modify stored credentials"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Advanced"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Credentials are not available for this user"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Installed for VPN and apps"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Installed for Wi‑Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Installed for Wi‑Fi (in use)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Remove all the contents?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Credential storage has been erased."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Credential storage couldn\'t be erased."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apps with usage access"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA certificate"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN and app user certificate"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Wi‑Fi certificate"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Your data won’t be private"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA certificates are used by websites, apps and VPNs for encryption. Only install CA certificates from organisations that you trust. \n\nIf you install a CA certificate, the certificate owner could access your data, such as passwords or credit card details, from websites that you visit or apps that you use – even if your data is encrypted."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Don’t install"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Install anyway"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certificate not installed"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Allow "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" to install certificates on this device?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"These certificates will verify you by sharing your device’s unique ID with the apps and URLs below"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Don\'t allow"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Allow"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Show more"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Certificate management app"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"None"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Certificates will verify you when you use the apps and URLs below"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Uninstall certificates"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Remove app"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Remove this app?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"This app won’t manage certificates, but it will stay on your device. Any certificates installed by the app will be uninstalled."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URLs}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Emergency dialling signal"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Set behaviour when an emergency call is placed"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Backup"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Backup &amp; restore"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Personal data"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Back up my data"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Back up app data, Wi‑Fi passwords and other settings to Google servers"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Backup account"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Manage backup account"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Include app data"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatic restore"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"When reinstalling an app, restore backed-up settings and data"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Backup service isn\'t active"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"No account is currently storing backed up data"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Stop backing up your Wi‑Fi passwords, bookmarks, other settings and app data, plus erase all copies on Google servers?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Stop backing up device data (such as Wi-Fi passwords and call history) and app data (such as settings and files stored by apps), plus erase all copies on remote servers?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Automatically back up device data (such as Wi-Fi passwords and call history) and app data (such as settings and files stored by apps) remotely.\n\nWhen you turn on automatic backup, device and app data is periodically saved remotely. App data can be any data that an app has saved (based on developer settings), including potentially sensitive data such as contacts, messages and photos."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Device admin settings"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Device admin app"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deactivate this device admin app"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Uninstall app"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deactivate &amp; uninstall"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Device admin apps"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"No device admin apps available"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"No available trust agents"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Activate device admin app?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Activate this device admin app"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Device admin"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Activating this admin app will allow the <xliff:g id="APP_NAME">%1$s</xliff:g> app to perform the following operations:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"This device will be managed and monitored by <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"This admin app is active and allows the <xliff:g id="APP_NAME">%1$s</xliff:g> app to perform the following operations:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Activate Profile Manager?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Allow supervision?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"By proceeding, your user will be managed by your admin, which may also be able to store associated data, in addition to your personal data.\n\nYour admin has the ability to monitor and manage settings, access, apps and data associated with this user, including network activity and your device\'s location information."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Other options are disabled by your admin"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Learn more"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Notification log"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Notification history"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Last %d hours"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Snoozed"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Recently dismissed"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# notification}other{# notifications}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Call ringtone &amp; vibrate"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Network details"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sync enabled"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sync disabled"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Syncing now"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Sync error..."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sync failed"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sync active"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sync"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sync is currently experiencing problems. It will be back shortly."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Add account"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Work profile isn\'t available yet"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Work apps"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Remove work profile"</string>
    <string name="background_data" msgid="321903213000101158">"Background data"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Apps can sync, send and receive data at any time"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Disable background data?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Disabling background data extends battery life and lowers data use. Some apps may still use the background data connection."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sync is ON"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sync is OFF"</string>
    <string name="sync_error" msgid="846923369794727644">"Sync error"</string>
    <string name="last_synced" msgid="1527008461298110443">"Last synced <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Syncing now…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Back up settings"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Back up my settings"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sync now"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Cancel sync"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Tap to sync now<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Calendar"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Contacts"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"App sync settings"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Data &amp; synchronisation"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Change password"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Account settings"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Remove account"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Add an account"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Remove account?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"This change isn\'t allowed by your admin"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Cannot sync manually"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Sync for this item is currently disabled. To change your preference, temporarily turn on background data and automatic sync."</string>
    <string name="delete" msgid="8330605554706263775">"Delete"</string>
    <string name="select_all" msgid="7898929601615536401">"Select all"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Data usage"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobile data and Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Auto-sync personal data"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Auto-sync work data"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Auto-sync private data"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Change cycle…"</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Day of month to reset data usage cycle:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"No apps used data during this period."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Foreground"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Background"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"restricted"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Turn off mobile data?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Set mobile data limit"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Set 4G data limit"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Set 2G-3G data limit"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Set Wi‑Fi data limit"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobile"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobile"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"None"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobile data"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G-3G data"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G data"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Foreground:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Background:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"App settings"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Background data"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Enable usage of mobile data in the background"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"To restrict background data for this app, first set a mobile data limit."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Restrict background data?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"This feature may cause an app that depends on background data to stop working when only mobile networks are available.\n\nYou can find more appropriate data usage controls in the settings available within the app."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Restricting background data is possible only when you’ve set a mobile data limit."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Turn auto-sync data on?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Turn auto-sync data off?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"This will conserve data and battery usage, but you\'ll need to sync each account manually to collect recent information and you won\'t receive notifications when updates occur."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Usage cycle reset date"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Date of each month:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Set"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Set data usage warning"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Set data usage limit"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Limiting data usage"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"warning"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"limit"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Removed apps"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Removed apps and users"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Network usage"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Metered"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Name"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Type"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Server address"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec identifier"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"IPSec preshared key"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec user certificate"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec CA certificate"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec server certificate"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Show advanced options"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Username"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Password"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Save account information"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(not used)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(don\'t verify server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(received from server)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"The information entered doesn\'t support always-on VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Cancel"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Dismiss"</string>
    <string name="vpn_save" msgid="683868204634860888">"Save"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Connect"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Replace"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Edit VPN profile"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Forget"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Connect to <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Disconnect this VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Disconnect"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Version"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Forget VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Replace existing VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Set always-on VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"When this setting is on, you won\'t have an Internet connection until the VPN successfully connects"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Your existing VPN will be replaced and you won\'t have an Internet connection until the VPN successfully connects"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"You\'re already connected to an always-on VPN. If you connect to a different one, your existing VPN will be replaced and always-on mode will turn off."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"You\'re already connected to a VPN. If you connect to a different one, your existing VPN will be replaced."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Turn on"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> can\'t connect"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"This app doesn\'t support always-on VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Add VPN profile"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Edit profile"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Delete profile"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Always-on VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"No VPNs added"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Stay connected to VPN at all times"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Not supported by this app"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Always on"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Not secure"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Block connections without VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Require VPN connection?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Not secure. Update to an IKEv2 VPN"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Failed to start unsupported VPN."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Select a VPN profile to always remain connected to. Network traffic will only be allowed when connected to this VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"None"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Always-on VPN requires an IP address for both server and DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"There is no network connection. Please try again later."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Disconnected from VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"None"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"A certificate is missing. Try editing the profile."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"System"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"User"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Disable"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Enable"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Uninstall"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Trust"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Enable the system CA certificate?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Disable the system CA certificate?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Permanently remove the user CA certificate?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Being used by"</string>
    <string name="credential_contains" msgid="3146519680449595771">"This entry contains"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 user key"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 user certificate"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA certificate"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA certificates"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Credential details"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Removed credential: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"No user credentials installed"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Spell checker"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Spell checker for work"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Type your current full backup password here"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Type a new password for full backups here"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Retype your new full backup password here"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Set backup password"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Cancel"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Additional system updates"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Network may be monitored"</string>
    <string name="done_button" msgid="6269449526248267">"Done"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Trust or remove certificate}other{Trust or remove certificates}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} has installed a certificate authority on your device, which may allow them to monitor your device network activity, including emails, apps and secure websites.\n\nFor more information about this certificate, contact your admin.}other{{orgName} has installed certificate authorities on your device, which may allow them to monitor your device network activity, including emails, apps and secure websites.\n\nFor more information about these certificates, contact your admin.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} has installed a certificate authority for your work profile, which may allow them to monitor work network activity, including emails, apps and secure websites.\n\nFor more information about this certificate, contact your admin.}other{{orgName} has installed certificate authorities for your work profile, which may allow them to monitor work network activity, including emails, apps and secure websites.\n\nFor more information about these certificates, contact your admin.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"A third party is capable of monitoring your network activity, including emails, apps and secure websites.\n\nA trusted credential installed on your device is making this possible."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Check certificate}other{Check certificates}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Multiple users"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Users &amp; profiles"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Add user or profile"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Restricted profile"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Not set up"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Not set up - Restricted profile"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Not set up – Work profile"</string>
    <string name="user_admin" msgid="4024553191395768119">"Admin"</string>
    <string name="user_you" msgid="3070562015202859996">"You (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"You can’t add any more users. Remove a user to add a new one."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Restricted profiles cannot add accounts"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Delete <xliff:g id="USER_NAME">%1$s</xliff:g> from this device"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Lock screen settings"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Add users from lock screen"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Switch to admin user when docked"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Delete yourself?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Delete this user?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Remove this profile?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Remove work profile?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"All apps and data will be deleted."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"All apps and data in this profile will be deleted if you continue."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"All apps and data will be deleted."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Adding new user…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Delete user"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Delete"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"All apps and data in this session will be deleted."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Remove"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Guest (you)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Users"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Other users"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Delete guest activity"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Delete all guest apps and data when exiting guest mode"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Delete guest activity?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Apps and data from this guest session will be deleted now, and all future guest activity will be deleted each time that you exit guest mode"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"delete, guest, activity, remove, data, visitor, erase"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Allow guest to make phone calls"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Call history will be shared with guest user"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Turn on phone calls &amp; SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Make this user an admin"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Delete user"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Turn on phone calls &amp; SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Call and SMS history will be shared with this user."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Remove admin privileges?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"If you remove admin privileges for this user, you or another admin can give them back later."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Emergency information"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Info and contacts for <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Open <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Allow apps and content"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Applications with restrictions"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Expand settings for application"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Choose apps to install"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Install available apps"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Contactless payments"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Default payment app"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"To make a payment using a payment app, hold the back of your device to a payment terminal"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Learn more"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Set work app as default payment app?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"To make a payment using a work app:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"work profile must be turned on."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"you’ll need to enter your work PIN, pattern or password if you have one."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"How it works"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Pay with your phone in shops"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Payment default"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Not set"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> - <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Use default payment app"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Use default payment app"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Always"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Except when another payment app is open"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"At a contactless terminal, pay with:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Paying at the terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Set up a payment app. Then just hold the back of your phone up to any terminal with the contactless symbol."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Got it"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"More…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Set default payment app"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Update default payment app"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"At a contactless terminal, pay with <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"At a contactless terminal, pay with <xliff:g id="APP_0">%1$s</xliff:g>.\n\nThis replaces <xliff:g id="APP_1">%2$s</xliff:g> as your default payment app."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Set default"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Update"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Work"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Restrictions"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Remove restrictions"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Change PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Help and feedback"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Account for content"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Photo ID"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Extreme threats"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Receive alerts for extreme threats to life and property"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Severe threats"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Receive alerts for severe threats to life and property"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER alerts"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Receive bulletins about child abductions"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Repeat"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Wireless emergency alerts"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Network operators"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Access point names"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Advanced Calling"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G Calling"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Use LTE services to improve voice calls (recommended)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Use 4G services to improve voice calls (recommended)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Use 5G for voice calls"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Send contacts to operator"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Send your contacts’ phone numbers to provide enhanced features"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Send contacts to <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Send contacts to your operator?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Your contacts’ phone numbers will be periodically sent to <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>This info identifies whether your contacts can use certain features, like video calls or some messaging features."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Your contacts’ phone numbers will be periodically sent to your operator.<xliff:g id="EMPTY_LINE">

</xliff:g>This info identifies whether your contacts can use certain features, like video calls or some messaging features."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Preferred network type"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (recommended)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS messages"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Send and receive when mobile data is off"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Switch mobile data automatically"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Use this network when it has better availability"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Work SIM"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"App &amp; content access"</string>
    <string name="user_rename" msgid="8735940847878484249">"RENAME"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Set app restrictions"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Controlled by <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"This app can access your accounts"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"This app can access your accounts. Controlled by <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi and Mobile"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Allow modification of Wi‑Fi and Mobile settings"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Allow modification of Bluetooth pairings and settings"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Location"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Let apps use your location information"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Back"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Next"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Format another way"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIMs"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobile data is unavailable"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Tap to select a data SIM"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Always use this for calls"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Choose SIM for mobile data"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Select a SIM for SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Switching data SIM, this may take up to a minute…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Use <xliff:g id="NEW_SIM">%1$s</xliff:g> for mobile data?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"If you switch to <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> will no longer be used for mobile data."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Use <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Call with"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Enter SIM name"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM slot %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Orange"</string>
    <string name="color_purple" msgid="6603701972079904843">"Purple"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"SIM status"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM status (SIM slot %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"SIMs changed."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Tap to set up"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Ask every time"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Selection required"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"SIM selection"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Settings"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Network and internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobile, Wi‑Fi, hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Connected devices"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, pairing"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, driving mode, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, driving mode"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, Driving mode, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, Driving mode"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Unavailable because NFC is off"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"To use, first install a payment app"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Recent apps, default apps"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Notification access is not available for apps in the work profile."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Passwords and accounts"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Saved passwords, autofill, synced accounts"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Default apps"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Cloned apps"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Create a second instance of an app so that you can use two accounts at the same time."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Apps that can be cloned."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> cloned, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> available to clone"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Delete all app clones"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Delete all app clones failed"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Creating…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Cloned"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Creating <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> clone"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Created <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> clone"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Languages, gestures, time, backup"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"System languages, app languages, regional preferences, speech"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, network connection, internet, wireless, data, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wi‑Fi notification, wi-fi notification"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"data usage"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Use 24-hour format"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Open with"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Applications"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"time zone"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Chat head, system, alert, window, dialogue, display, on top other apps, draw"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Flashlight, Light, Torch"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, toggle, control"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobile, mobile operator, wireless, data, 4g,3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wi-fi, Wi-Fi, call, calling"</string>
    <string name="keywords_display" msgid="874738809280751745">"screen, touchscreen"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"dim screen, touchscreen, battery, bright"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"dim screen, night, tint, night shift, brightness, screen colour, colour, color"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"background, personalise, customise display"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"text size"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"project, cast, Screen mirroring, Screen sharing, mirroring, share screen, screen casting"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"space, disk, hard drive, device usage"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"power usage, charge"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"view battery usage, battery usage, power usage"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"battery saver, power saver, saver"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"adaptive preferences, adaptive battery"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"spelling, dictionary, spellcheck, auto-correct"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"recogniser, input, speech, speak, language, hands-free, hand free recognition, offensive word, audio history, Bluetooth headset"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"rate, language, default, speak, speaking, tts, accessibility, screen reader, blind"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"clock, military"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"reset, restore, factory"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"wipe, delete, restore, clear, remove, factory reset"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printer"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"speaker beep, speaker, volume, mute, silence, audio, music, haptic, vibrator, vibrate"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"don\'t disturb, interrupt, interruption, break"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"nearby, location, history, reporting, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"account, add an account, work profile, add account, remove, delete"</string>
    <string name="keywords_users" msgid="3497517660077620843">"restriction, restrict, restricted"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"text correction, correct, sound, vibrate, auto, language, gesture, suggest, suggestion, theme, offensive, word, type, emoji, international"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"reset, preferences, default"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apps, download, applications, system"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apps, permissions, security"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apps, default"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignore optimisations, doze, app standby"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"vibrant, RGB, sRGB, colour, natural, standard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, resolution, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"colour, temperature, D65, D73, white, yellow, blue, warm, cool"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"slide to unlock, password, pattern, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"screen pinning"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"work challenge, work, profile"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"work profile, managed profile, unify, unification, work, profile"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"awake, sleep, do not lock, stay unlocked on fold, folding, closing, fold, close, screen off"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestures"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"pay, tap, payments"</string>
    <string name="keywords_backup" msgid="707735920706667685">"backup, back up"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"face, unlock, auth, sign in"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"face, unlock, auth, sign in, fingerprint, biometric"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl version, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"network, mobile network state, service state, signal strength, mobile network type, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"network, mobile network state, service state, signal strength, mobile network type, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"network, mobile network state, service state, signal strength, mobile network type, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"network, mobile network state, service state, signal strength, mobile network type, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serial number, hardware version"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"battery info, manufacture date, cycle count, first use"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"android security patch level, baseband version, kernel version"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"theme, light, dark, mode, light sensitivity, photophobia, make darker, darken, dark mode, migraine"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"dark theme"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"bug"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambient display, Lock screen display"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"lock screen notification, notifications"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"face"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"fingerprint, add fingerprint"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"face, fingerprint, add fingerprint"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"watch unlock, add watch unlock"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"dim screen, touchscreen, battery, smart brightness, dynamic brightness, Auto brightness"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smart, dim screen, sleep, battery, timeout, attention, display, screen, inactivity"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"camera, smart, auto rotate, auto-rotate, rotate, flip, rotation, portrait, landscape, orientation, vertical, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"upgrade, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, schedule, notifications, block, silence, vibrate, sleep, work, focus, sound, mute, day, weekday, weekend, weeknight, event"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"screen, lock time, timeout, lockscreen"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memory, cache, data, delete, clear, free, space"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"connected, device, headphones, headset, speaker, wireless, pair, earbuds, music, media"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"background, theme, grid, customise, personalise"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"icon, accent, colour, home screen, lock screen, shortcut, clock size"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"default, assistant"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"payment, default"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"incoming notification"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb tether, bluetooth tether, wifi hotspot"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"haptics, vibrate, vibration"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptics, vibrate, screen, sensitivity"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"haptics, vibrate, phone, call, sensitivity, ring"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"haptics, vibrate, phone, call, ring, gradually"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"haptics, vibrate, sensitivity, notification"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"haptics, vibrate, sensitivity, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"haptics, vibrate, sensitivity, media"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"haptics, vibrate, vibration"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"battery saver, sticky, persist, power saver, battery"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"routine, schedule, battery saver, power saver, battery, automatic, per cent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"VoLTE, advanced calling, 4G calling"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, advanced calling, 5g calling"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"add language, add a language"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"text size, large print, large font, large text, low vision, make text bigger, font enlarger, font enlargement"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"always on ambient display, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, tag, reader"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"keyboard, haptics, vibrate,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volume, vibration, Do Not Disturb"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Media volume"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Cast volume"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Call volume"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Alarm volume"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Ring and notification volume"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Ring volume"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Notification volume"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Ringer silent"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Ringer vibrate"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Notification volume muted, notifications will vibrate"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> muted"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Unavailable because ring is muted"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Phone ringtone"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Default notification sound"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"App provided sound"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Default notification sound"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Default alarm sound"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibrate first, then ring gradually"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Spatial audio"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Dial pad tones"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Screen locking sound"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Charging sounds and vibration"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Docking sounds"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Tap and click sounds"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Always show icon when in vibrate mode"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Dock speaker plays"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"All audio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Media audio only"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Silence"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tones"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrations"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Power on sounds"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Live Caption"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatically caption media"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Wired headphones"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Audio from compatible media becomes more immersive"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Off"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"On/<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"On / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> and <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"You can also turn on spatial audio for Bluetooth devices."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Connected devices settings"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{None}=1{1 schedule set}other{# schedules set}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Do Not Disturb"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Only get notified by important people and apps"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Limit interruptions"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Turn on Do Not Disturb"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarms and media sounds can interrupt"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Schedules"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Delete schedules"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Delete"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Edit"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Schedules"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Schedule"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Schedule"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Silence phone at certain times"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Set do not disturb rules"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Schedule"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Use schedule"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Allow interruptions that make sound"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Block visual disturbances"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Allow visual signals"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Display options for hidden notifications"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"When Do Not Disturb is on"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"No sound from notifications"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"You will see notifications on your screen"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"When notifications arrive, your phone won’t make a sound or vibrate."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"No visuals or sound from notifications"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"You won’t see or hear notifications"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Your phone won’t show, vibrate or make sound for new or existing notifications. Bear in mind that critical notifications for device activity and status will still appear.\n\nWhen you turn off Do Not Disturb, find missed notifications by swiping down from the top of your screen."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Custom"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Enable custom setting"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Remove custom setting"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"No sound from notifications"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Partially hidden"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"No visuals or sound from notifications"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Custom restrictions"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"When the screen is on"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"When the screen is off"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Mute sound and vibration"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Don\'t turn on screen"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Don\'t blink light"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Don\'t pop notifications on screen"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Hide status bar icons at top of screen"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Hide notification dots on app icons"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Don\'t wake for notifications"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Hide from pull-down shade"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Never"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"When screen is off"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"When screen is on"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Sound and vibration"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Sound, vibration and some visual signs of notifications"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Sound, vibration and visual signs of notifications"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Notifications needed for basic device activity and status will never be hidden."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"None"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"other options"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Add"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Turn on"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Turn on now"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Turn off now"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Do Not Disturb is on until <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Do Not Disturb will stay on until you turn it off"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Do Not Disturb was automatically turned on by a schedule (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Do Not Disturb was automatically turned on by an app (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Do Not Disturb is on for <xliff:g id="RULE_NAMES">%s</xliff:g> with custom settings."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"View custom settings"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Priority only"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"On/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"On"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Ask every time"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Until you turn off"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 hour}other{# hours}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minute}other{# minutes}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Off}=1{Off/1 schedule can turn on automatically}other{Off/# schedules can turn on automatically}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"What can interrupt Do Not Disturb"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"People"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apps"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarms and other interruptions"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Schedules"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Duration for Quick Settings"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"General"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"When Do Not Disturb is on, sound and vibration will be muted, except for the items that you allow above."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Custom settings"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Review schedule"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Got it"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notifications"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Duration"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Messages, events &amp; reminders"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"When Do Not Disturb is on, messages, reminders and events will be muted, except for the items that you allow above. You can adjust message settings to allow your friends, family or other contacts to get in touch with you."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Finished"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Settings"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"No visuals or sound from notifications"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"No sound from notifications"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"You won’t see or hear notifications. Calls from starred contacts and repeat callers are allowed."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Current setting)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Change Do Not Disturb notification settings?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Work profile sounds"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Use personal profile sounds"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Use the same sounds as your personal profile"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Work phone ringtone"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Default work notification sound"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Default work alarm sound"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Same as personal profile"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Use personal profile sounds?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Confirm"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Your work profile will use the same sounds as your personal profile"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notifications"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Notification history, conversations"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Conversation"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Manage"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"App notifications"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Control notifications from individual apps"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"General"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Work notifications"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Work profile"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Adaptive notification priority"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Automatically set lower priority notifications to Gentle"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Adaptive notification ranking"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automatically rank notifications by relevance"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Adaptive notification feedback"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indicate adjustments made to notifications and show the option to provide feedback to the system"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Reset notification importance"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Reset user-changed importance settings and allow notification assistant to prioritise"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Suggested actions and replies"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automatically show suggested actions and replies"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Show recent and snoozed notifications"</string>
    <string name="notification_history" msgid="8663811361243456201">"Notification history"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Use notification history"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Notification history turned off"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Turn on notification history to see recent notifications and snoozed notifications"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"No recent notifications"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Your recent and snoozed notifications will appear here"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"view notification settings"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"open notification"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Allow notification snoozing"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Notification dot on app icon"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bubbles"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bubbles"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Bubble this conversation"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Show floating icon on top of apps"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Turn on bubbles for device?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Turning on bubbles for this app will also turn on bubbles for your device.\n\nThis affects other apps or conversations that are allowed to bubble."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Turn on"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Cancel"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"On/Conversations can appear as floating icons"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Allow apps to show bubbles"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Some conversations will appear as floating icons on top of other apps"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"All conversations can bubble"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Selected conversations can bubble"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nothing can bubble"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Conversations"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"All conversations can bubble except"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Turn off bubbles for this conversation"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Turn on bubbles for this conversation"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Swipe right to dismiss, left to show menu"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Swipe left to dismiss, right to show menu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Hide silent notifications in status bar"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Blink light"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privacy"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Skip lock screen"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"After unlocking, go directly to last used screen. Notifications won’t show on lock screen. Swipe down from top to see them."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Lock screen, Lockscreen, Skip, Bypass"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"When work profile is locked"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Show only new notifications on lock screen"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Automatically remove previously viewed notifications from the lock screen"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notifications on lock screen"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Show conversations, default and silent"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Show conversations, default and silent"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Hide silent conversations and notifications"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Don’t show any notifications"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Sensitive notifications"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Show sensitive content when locked"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Sensitive work profile notifications"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Show sensitive work profile content when locked"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Show all notification content"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Show sensitive content only when unlocked"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Don\'t show notifications at all"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"What do you want your lock screen to show?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Lock screen"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Show all work notification content"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Hide sensitive work content"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"When your device is locked, how do you want profile notifications to be displayed?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profile notifications"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notifications"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"App notifications"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Notification category"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Behaviour"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Conversations"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Conversation section"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Allow app to use conversation section"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Not a conversation"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Remove from the conversation section"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"This is a conversation"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Add to the conversation section"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"No priority conversations"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# priority conversation}other{# priority conversations}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Priority conversations"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Show at top of conversation section and appear as floating bubbles"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Show at top of conversation section"</string>
    <string name="other_conversations" msgid="551178916855139870">"Non-priority conversations"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Conversations that you’ve made changes to"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Recent conversations"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Clear recent conversations"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Recent conversations removed"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Conversation removed"</string>
    <string name="clear" msgid="5092178335409471100">"Clear"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Clear <xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Priority and modified conversations will appear here"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Once you mark a conversation as priority, or make any other changes to conversations, they will appear here. \n\nTo change conversation settings: \nSwipe down from the top of the screen to open the pull-down shade, then touch and hold a conversation."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimise"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Pop on screen"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Silent"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Default"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Allow interruptions"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Let the app make sound, vibrate and/or pop notifications on screen"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Priority"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Shows at top of conversation section, appears as floating bubble, displays profile picture on lock screen"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> doesn’t support most conversation features. You can’t set a conversation as priority, and conversations won’t appear as floating bubbles."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"In the pull-down shade, collapse notifications to one line"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"No sound or vibration"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"No sound or vibration and appears lower in conversation section"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"May ring or vibrate based on device settings"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"When device is unlocked, show notifications as a banner across the top of the screen"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"All \'<xliff:g id="APP_NAME">%1$s</xliff:g>\' notifications"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"All <xliff:g id="APP_NAME">%1$s</xliff:g> notifications"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{About # notification per day}other{About # notifications per day}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{About # notification per week}other{About # notifications per week}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Never"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Device and app notifications"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Control which apps and devices can read notifications"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Access to work profile notifications is blocked"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Enhanced notifications"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Get suggested actions, replies and more"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"None"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"No installed apps have requested notification access."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Allow notification access"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Enhanced notifications replaced Android adaptive notifications in Android 12. This feature shows suggested actions and replies, and organises your notifications. \n\nEnhanced notifications can access notification content, including personal information like contact names and messages. This feature can also dismiss or respond to notifications, such as answering phone calls, and control Do Not Disturb."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Allow notification access for <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"The <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> app will be able to read all notifications, including personal information such as contact names, photos and the text of messages that you receive. This app will also be able to snooze or dismiss notifications or take action on buttons in notifications, including answering phone calls. \n\nThis will also give the app the ability to turn Do Not Disturb on or off and change related settings."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"The <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> app will be able to:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Read your notifications"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"It can read your notifications, including personal information such as contacts, messages and photos."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Reply to messages"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"It can reply to messages and take action on buttons in notifications, including snoozing or dismissing notifications and answering calls."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Change settings"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"It can turn Do Not Disturb on or off and change related settings."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"If you turn off notification access for <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, Do Not Disturb access may also be turned off."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Turn off"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Cancel"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Real-time"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Ongoing communication from apps in use, navigation, phone calls and more"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Conversations"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, text messages and other communications"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Notifications"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"May ring or vibrate based on settings"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Silent"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Notifications that never make sound or vibrations"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Allowed"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Not allowed"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"See all apps"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Change settings for each app that sends notifications"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Apps shown on device"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"This app doesn’t support enhanced settings"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"More settings"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"More settings are available inside this app"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Notification cooldown"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Apply cooldown to all notifications"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Gradually lower the notification volume when you get many successive notifications from the same app"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Apply cooldown to conversations"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Gradually lower the notification volume when you get many messages from the same chat within a short period of time"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Don\'t use notification cooldown"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Never lower notification volume, regardless of the amount of successive notifications from the same app"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Vibrate when unlocked"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Only vibrate when screen is unlocked"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Apply to work profiles"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Apply the notification cooldown settings from your personal profile to your work profile"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR helper services"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"No installed apps have requested to be run as VR helper services."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Allow VR service access for <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> will be able to run when you are using applications in virtual reality mode."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"When device is in VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Reduce blur (recommended)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Reduce flicker"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Picture-in-picture"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"No installed apps support picture-in-picture"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip picture in"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Allow picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Allow this app to create a picture-in-picture window while the app is open or after you leave it (for example, to continue watching a video). This window displays on top of other apps that you\'re using."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Connected work and personal apps"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Connected"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Not connected"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"No connected apps"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"cross profile connected app apps work and personal"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Connected"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Connect these apps"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Connected apps share permissions and can access each other’s data."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Only connect apps if you trust them not to share personal data with your IT admin."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"You can disconnect apps at any time in your device’s privacy settings."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Trust work <xliff:g id="NAME">%1$s</xliff:g> with your personal data?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Only connect apps if you trust them not to share personal data with your IT admin."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"App data"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"This app can access data in your personal <xliff:g id="NAME">%1$s</xliff:g> app."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Permissions"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"This app can use your personal <xliff:g id="NAME">%1$s</xliff:g> app’s permissions, like access to location, storage or contacts."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"No apps connected"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# app connected}other{# apps connected}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"To connect these apps, install <xliff:g id="NAME">%1$s</xliff:g> in your work profile"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"To connect these apps, install <xliff:g id="NAME">%1$s</xliff:g> in your personal profile"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Tap to get the app"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Do Not Disturb access"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Allow Do Not Disturb"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"No installed apps have requested Do Not Disturb access"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"You haven\'t allowed notifications from this app"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"At your request, Android is blocking this category of notifications from appearing on this device"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"At your request, Android is blocking this group of notifications from appearing on this device"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"This app does not send notifications"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Categories"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Other"</string>
    <string name="no_channels" msgid="4716199078612071915">"This app has not posted any notifications"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Additional settings in the app"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# category deleted}other{# categories deleted}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Block all"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Never show these notifications"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Show notifications"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Never show notifications in the shade or on peripheral devices"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Allow full-screen notifications"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Allow notifications to take up the full screen when the device is locked"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Allow notification dot"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Show notification dot"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Override Do Not Disturb"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Let these notifications continue to interrupt when Do Not Disturb is on"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Lock screen"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Done"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Blink light"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibration"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Sound"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Priority"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Schedule name"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Enter schedule name"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Schedule name already in use"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Add more"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Add event schedule"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Add time schedule"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Choose schedule type"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Delete \'<xliff:g id="RULE">%1$s</xliff:g>\' rule?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Delete"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"These settings can\'t be changed at the moment. An app (<xliff:g id="APP_NAME">%1$s</xliff:g>) has automatically turned on Do Not Disturb with custom behaviour."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"These settings can\'t be changed at the moment. An app has automatically turned on Do Not Disturb with custom behaviour."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"These settings can\'t be changed at the moment. Do Not Disturb was manually turned on with custom behaviour."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Time"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Event"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"During events for"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Any calendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Where reply is"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Yes, Maybe or Not replied"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Yes or Maybe"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Yes"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Rule not found."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"On/<xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Days"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"None"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarm can override end time"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Schedule turns off when an alarm rings"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Do Not Disturb behaviour"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Use default settings"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Create custom settings for this schedule"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"For ‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Conversations"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"All conversations"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Priority conversations"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"priority conversations"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"None"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{None}=1{1 conversation}other{# conversations}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Who can interrupt"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Even if messaging or calling apps can\'t notify you, people that you choose here can still reach you through those apps"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Calls"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Calls"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"calls"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Calls that can interrupt"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"To make sure that allowed calls make a sound, check that the device is set to ring"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"For ‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’, incoming calls are blocked. You can adjust settings to allow your friends, family or other contacts to reach you."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Starred contacts"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{None}=1{{contact_1}}=2{{contact_1} and {contact_2}}=3{{contact_1}, {contact_2} and {contact_3}}other{{contact_1}, {contact_2} and # others}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(No name)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Messages"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"messages"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Messages"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Messages that can interrupt"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"To make sure that allowed messages make a sound, check that the device is set to ring"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"For ‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’, incoming messages are blocked. You can adjust settings to allow your friends, family or other contacts to reach you."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"All messages can reach you"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"All calls can reach you"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{None}=1{1 contact}other{# contacts}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Anyone"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Contacts"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Starred contacts"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"None"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"None"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarms"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"From timers, alarms, security systems and other apps"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarms"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarms"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Media sounds"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Sounds from videos, games and other media"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"media"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Media"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Touch sounds"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Sounds from the keyboard and other buttons"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"touch sounds"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Touch sounds"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Reminders"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"From tasks and reminders"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"reminders"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Reminders"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Calendar events"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"From upcoming calendar events"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"events"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Events"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Allow apps to override"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apps that can interrupt"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Select more apps"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"No apps selected"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"No apps can interrupt"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Add apps"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"All notifications"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Some notifications"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Selected people can still reach you, even if you don’t allow apps to interrupt"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{No apps can interrupt}=1{{app_1} can interrupt}=2{{app_1} and {app_2} can interrupt}=3{{app_1}, {app_2} and {app_3} can interrupt}other{{app_1}, {app_2} and # more can interrupt}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apps"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notifications that can interrupt"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Allow all notifications"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nothing can interrupt}=1{{sound_category_1} can interrupt}=2{{sound_category_1} and {sound_category_2} can interrupt}=3{{sound_category_1}, {sound_category_2} and {sound_category_3} can interrupt}other{{sound_category_1}, {sound_category_2} and # more can interrupt}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nothing can interrupt"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"No one can interrupt"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Some people can interrupt"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"All people can interrupt"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Repeat callers"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Allow repeat callers"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"anyone"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"contacts"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"starred contacts"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"repeat callers"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> and <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"If the same person calls a second time within a <xliff:g id="MINUTES">%d</xliff:g>-minute period"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Start time"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"End time"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> next day"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Change to alarms only indefinitely"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Change to alarms only for one minute until {time}}other{Change to alarms only for # minutes (until {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Change to alarms only for one hour until {time}}other{Change to alarms only for # hours until {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Change to alarms only until <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Change to always interrupt"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Warning"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Close"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Send feedback about this device"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Enter admin PIN"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"On"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Off"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"On"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Off"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"On"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Off"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"App pinning"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"App pinning allows you to keep the current app in view until you unpin it. This feature can be used, for example, to let a trusted friend play a specific game."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"When an app is pinned, the pinned app may open other apps and personal data may be accessible. \n\nTo use app pinning: 	\n{0,number,integer}. Turn on app pinning 	\n{1,number,integer}. Open Overview 	\n{2,number,integer}. Tap the app icon at the top of the screen, then tap Pin"</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"When an app is pinned, the pinned app may open other apps and personal data may be accessible. \n\nIf you want to share your device with someone securely, try using a guest user instead. \n\nTo use app pinning: 	\n{0,number,integer}. Turn on app pinning 	\n{1,number,integer}. Open Overview 	\n{2,number,integer}. Tap the app icon at the top of the screen, then tap Pin"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"When app is pinned: \n\n• Personal data may be accessible \n(such as contacts and email content) \n• Pinned app may open other apps \n\nOnly use app pinning with people you trust."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Ask for unlock pattern before unpinning"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Ask for PIN before unpinning"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Ask for password before unpinning"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Lock device when unpinning"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Confirm SIM deletion"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Verify that it\'s you before erasing an eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Advanced memory protection beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Advanced memory protection"</string>
    <string name="memtag_intro" msgid="579408691329568953">"This beta feature helps you protect your device from bugs that may put your security at risk."</string>
    <string name="memtag_on" msgid="824938319141503923">"On"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Off"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"On after restart"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Off after restart"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Currently unavailable for your device"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Always on for your device"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"You\'ll have to restart your device to turn advanced memory protection on or off. When it\'s on, you may notice slower device performance."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Restart device?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"You\'ll need to restart your device to turn on advanced memory protection."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"You\'ll need to restart your device to turn off advanced memory protection."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Restart"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Not now"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Learn more about advanced memory protection."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"This work profile is managed by:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Managed by <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Open by default"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Open supported links"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Allow web links to open in this app"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Links to open in this app"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Supported links"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Other default preferences"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Add link"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"An app can verify links to automatically open in the app."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# verified link}other{# verified links}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{This link is verified and automatically opens in this app.}other{These links are verified and automatically open in this app.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Show verified links list"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Checking for other supported links…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Cancel"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# supported link}other{# supported links}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Add"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Opens in <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> used in <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"internal storage"</string>
    <string name="storage_type_external" msgid="125078274000280821">"external storage"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> used since <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Storage used"</string>
    <string name="change" msgid="273206077375322595">"Change"</string>
    <string name="change_storage" msgid="8773820275624113401">"Change storage"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notifications"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"On"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g> / <xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Off"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# category turned off}other{# categories turned off}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# additional permission}other{# additional permissions}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"No permissions granted"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"No permissions requested"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Control app access to your data"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privacy dashboard"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Show which apps recently used permissions"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Unused apps"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# unused app}other{# unused apps}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Unused app settings"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pause app activity if unused"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Remove permissions, delete temporary files and stop notifications"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Manage app if unused"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Remove permissions, delete temporary files, stop notifications and archive the app"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"All apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Installed apps"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Instant Apps"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Turned off"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Advanced"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Permission manager"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Data sharing updates for location"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Review apps that changed the way they may share your location data"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Tap to wake"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Double-tap anywhere on the screen to wake device"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Opening links"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Don’t open supported links"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Open <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Open <xliff:g id="DOMAIN">%s</xliff:g> and other URLs"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Allow app to open supported links"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Ask every time"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Don’t allow app to open links"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{App claims to handle # link}other{App claims to handle # links}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"App claims to handle following links:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Assist and voice input"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digital assistant app"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Default digital assistant app"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Agree"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Browser app"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Phone app"</string>
    <string name="system_app" msgid="1863291702508355041">"(System)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Apps storage"</string>
    <string name="usage_access" msgid="5487993885373893282">"Usage access"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Permit usage access"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Screen time"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Usage access allows an app to track which other apps you\'re using and how often, as well as your operator, language settings and other details."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memory"</string>
    <string name="always_running" msgid="9012705720688200252">"Always running (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Sometimes running (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Rarely running (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Battery optimisation"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Not optimised"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Not optimised"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimising battery use"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Battery optimisation not available"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Let app always run in background?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Allowing <xliff:g id="APP_NAME">%1$s</xliff:g> to always run in the background may reduce battery life. \n\nYou can change this later from Settings &gt; Apps."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> use since last full charge"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> use for past 24 hours"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"No battery use since last full charge"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Share bug report?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Your IT admin requested a bug report to help troubleshoot this device. Apps and data may be shared."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Your IT admin requested a bug report to help troubleshoot this device. Apps and data may be shared, and your device may temporarily slow down."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"This bug report is being shared with your IT admin. Contact them for more details."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Share"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Decline"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"No data transfer"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Charge connected device"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"File transfer"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webcam"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Convert videos to AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videos will play on more media players, but quality may be reduced"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB tethering"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Use USB for"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Default USB configuration"</string>
    <string name="usb_default_info" msgid="167172599497085266">"When another device is connected and your phone is unlocked, these settings will be applied. Only connect to trusted devices."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Power options"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"File transfer options"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB Preferences"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB controlled by"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Connected device"</string>
    <string name="usb_control_device" msgid="527916783743021577">"This device"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Switching…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Couldn\'t switch"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Charging this device"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Charging connected device"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"File transfer"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB tethering"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Webcam"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"File transfer and supplying power"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB tethering and supplying power"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP and supplying power"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI and supplying power"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webcam and supplying power"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Background check"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Use text from screen"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Allow the assist app to access the screen contents as text"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Use screenshot"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Allow the assist app to access an image of the screen"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Flash screen"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Flash edges of screen when assist app accesses text from screen or screenshot"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Assist apps can help you based on information from the screen that you’re viewing. Some apps support both launcher and voice input services to give you integrated assistance."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Average memory use"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maximum memory use"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Memory usage"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"App usage"</string>
    <string name="memory_details" msgid="6133226869214421347">"Details"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> avg memory used in last 3 hours"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"No memory used in last 3 hours"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sort by avg. use"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sort by max. use"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Performance"</string>
    <string name="total_memory" msgid="5244174393008910567">"Total memory"</string>
    <string name="average_used" msgid="690235917394070169">"Average used (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Free"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memory used by apps"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 app used memory in the last {time}}other{# apps used memory in the last {time}}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Enable memory usage profiling"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"Memory usage profiling requires additional system resources."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Memory profiling disabled"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frequency"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maximum usage"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"No data used"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Allow access to Do Not Disturb for <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"The app will be able to turn Do Not Disturb on or off, and make changes to related settings."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Must stay turned on because notification access is on"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Revoke access to Do Not Disturb for <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"All Do Not Disturb rules created by this app will be removed."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Don’t optimise"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimise"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"May drain your battery more quickly. App will no longer be restricted from using background battery."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Recommended for better battery life"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"None"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Turning off usage access for this app doesn\'t prevent your admin from tracking data usage for apps in your work profile"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Display over other apps"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Display over other apps"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Allow display over other apps"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Allow this app to display on top of other apps that you’re using. This app will be able to see where you tap or change what’s displayed on the screen."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Change media output"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Allow app to switch media output"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Allow this app to choose which connected device plays audio or video from other apps. If allowed, this app can access a list of available devices such as headphones and speakers and choose which output device is used to stream or cast audio or video."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"All files access"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Allow access to manage all files"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Allow this app to read, modify and delete all files on this device or any connected storage volumes. If granted, app may access files without your explicit knowledge."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Can access all files"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Voice activation apps"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Allow voice activation"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Voice activation turns on approved apps, hands-free, using voice command. Built-in adaptive sensing ensures data stays private only to you.\n\n"<a href="">"More about protected adaptive sensing"</a></string>
    <string name="permit_receive_sandboxed_detection_training_data" msgid="3929496847420108753">"Improve voice activation"</string>
    <string name="receive_sandboxed_detection_training_data_description" msgid="1415687008184625050">"This device uses private intelligence to improve the voice activation model. Apps can receive summarised updates that are aggregated across many users to maintain privacy while improving the model for everyone.\n\n"<a href="">"More about private intelligence"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Full-screen notifications"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Allow full-screen notifications from this app"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Allow this app to show notifications that take up the full screen when the device is locked. Apps may use these to highlight alarms, incoming calls or other urgent notifications."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Media management apps"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Allow app to manage media"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"If allowed, this app can modify or delete media files created with other apps without asking you. App must have permission to access files and media."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Media, File, Management, Manager, Manage, Edit, Editor, App, Application, Program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"VR virtual reality listener stereo helper service"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Display over other apps"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Apps with permission"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Allowed"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Not allowed"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"install apps unknown sources"</string>
    <string name="write_settings" msgid="6864794401614425894">"Modify system settings"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"write modify system settings"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Can install other apps"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Can modify system settings"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Can modify system settings"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Modify system settings"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Allow modifying system settings"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"This permission allows an app to modify system settings."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Allow from this source"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Double twist for camera"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Open the camera app by twisting your wrist twice"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Display size"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Make everything bigger or smaller"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"display, density, screen zoom, scale, scaling"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Preview"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Make smaller"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Make larger"</string>
    <string name="disconnected" msgid="3469373726996129247">"Not connected"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Not connected"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> apps installed"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> used – <xliff:g id="FREE_SPACE">%2$s</xliff:g> free"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Dark theme, font size, brightness"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Avg <xliff:g id="USED_MEMORY">%1$s</xliff:g> of <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> memory used"</string>
    <string name="users_summary" msgid="8473589474976307510">"Signed in as <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Updated to Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Update available"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blocked by work policy"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Can’t change volume"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Can’t make calls"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Can’t send SMS messages"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Can’t use camera"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Can’t take screenshots"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Can’t open this app"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blocked by your credit provider"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Parent needed"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Hand the phone to your parent to start setting this up"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Hand the phone to your parent to allow this setting to be changed."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"For more info, contact your IT admin"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"More details"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Your admin can monitor and manage apps and data associated with your work profile, including settings, permissions, corporate access, network activity and the device\'s location information."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Your admin can monitor and manage apps and data associated with this user, including settings, permissions, corporate access, network activity and the device\'s location information."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Your admin can monitor and manage apps and data associated with this device, including settings, permissions, corporate access, network activity and the device\'s location information."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Your device administrator may be able to access data associated with this device, manage apps and change this device\'s settings."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Turn off"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Turn on"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Show"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Hide"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot is active"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Aeroplane mode is on"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Networks unavailable"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Do Not Disturb is on"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Phone muted"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"With exceptions"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Battery Saver is on"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Features restricted"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobile data is off"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet only available via Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Data saver"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Features restricted"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Work profile is off"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"For apps &amp; notifications"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Turn on sound"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Ringer muted"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"For calls &amp; notifications"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Vibration only"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"For calls &amp; notifications"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Set Night Light schedule"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Automatically tint screen every night"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Night Light is on"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Screen tinted amber"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Grey scale"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Display only in grey colour"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Collapse"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Cool colour temperature"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Use cooler display colours"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"To apply colour change, turn off screen"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Camera laser sensor"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatic system updates"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Apply updates when device restarts"</string>
    <string name="usage" msgid="287782903846013936">"Usage"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobile data usage"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"App data usage"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Wi‑Fi data usage"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Non-operator data usage"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Ethernet data usage"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobile data"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> Wi-Fi data"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> ethernet data"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Data warning and limit"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Mobile data usage cycle"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"<xliff:g id="ID_1">^1</xliff:g> data warning"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g> data limit"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"<xliff:g id="ID_1">^1</xliff:g> data warning/<xliff:g id="ID_2">^2</xliff:g> data limit"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Excludes data used by operator networks"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> used"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Set data warning"</string>
    <string name="data_warning" msgid="2925054658166062884">"Data warning"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Data warning and data limit are measured by your device. This may be different from operator data."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Set data limit"</string>
    <string name="data_limit" msgid="8731731657513652363">"Data limit"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> used <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Configure"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Other apps included in usage"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 app allowed to use unrestricted data when Data Saver is on}other{# apps allowed to use unrestricted data when Data Saver is on}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primary data"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Wi‑Fi data"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> used"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> over"</string>
    <string name="data_remaining" msgid="6316251496381922837">"<xliff:g id="ID_1">^1</xliff:g> left"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graph showing data usage between <xliff:g id="START_DATE">%1$s</xliff:g> and <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"No data in this date range"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# day left}other{# days left}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"No time remaining"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Less than one day left"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Updated by <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> ago"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Updated <xliff:g id="ID_1">^2</xliff:g> ago"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Updated by <xliff:g id="ID_1">^1</xliff:g> just now"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Updated just now"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"View details"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Data Saver"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Unrestricted data"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Background data is turned off"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"On"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Off"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Use Data Saver"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Unrestricted data usage"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Allow unrestricted data access when Data Saver is on"</string>
    <string name="home_app" msgid="6056850504746902747">"Home app"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Add another fingerprint"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Unlock with a different finger"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"On"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Will turn on at <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Off"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"App battery usage"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Set battery usage for apps"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"View settings"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Check"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Got it"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Is this message helpful?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Battery tips warning icon"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Turn on adaptive brightness to extend battery life"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Reduce screen timeout to extend battery life"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> used more battery"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> used more battery than usual"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> used more battery while in the background"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> used more battery than usual while in the background"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> used more battery while in the foreground"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> used more battery than usual while in the foreground"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Battery usage anomaly"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"High battery usage"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"High battery usage in the background"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"High battery usage in the foreground"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Unrestricted"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimised"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Restricted"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Default spell checker"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Choose spell checker"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Use spellchecker"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Not selected"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"key"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"group"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(summary)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"importance"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"explanation"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"can show badge"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intent"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"delete intent"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"full screen intent"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"actions"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"title"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"remote inputs"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"customised view"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"extras"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"icon"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"parcel size"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"notification alerted"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"channel"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Ranking object is missing."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Ranking object doesn\'t contain this key."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Display cutout"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"display cutout, notch"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Device default"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Failed to apply overlay"</string>
    <string name="special_access" msgid="1767980727423395147">"Special app access"</string>
    <string name="special_access_more" msgid="132919514147475846">"See more"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Long background tasks"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Allow long-running background tasks"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Long background tasks"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Allow this app to run long background tasks. This lets the app run tasks that might take longer than a few minutes to finish, such as downloads and uploads. \n\nIf this permission is denied, the system will limit how long the app can perform such tasks in the background."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"long jobs, data transfer, background tasks"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Reset ShortcutManager rate-limiting"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"ShortcutManager rate-limiting has been reset"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Control info on lock screen"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Show or hide notification content"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tips and support"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Smallest width"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"No installed apps have requested Premium SMS access"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Premium SMS may cost you money and will add up to your mobile bills. If you enable permission for an app, you will be able to send premium SMS using that app."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Premium SMS access"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Off"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Connected to <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Connected to multiple devices"</string>
    <string name="demo_mode" msgid="6566167465451386728">"System UI demo mode"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Dark theme"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Temporarily disabled due to Battery Saver"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Temporarily disabled due to Battery Saver"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Turn off Battery Saver"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Temporarily turned on due to Battery Saver"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Try Dark theme"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Helps extend battery life"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Quick settings developer tiles"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Disable adb authorisation timeout"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Disable automatic revocation of adb authorisations for systems that have not reconnected within the default (seven days) or user-configured (minimum one day) amount of time."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensors Off"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Work profile settings"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Search for work directory contacts in personal apps"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Your searches and incoming calls may be visible to your IT admin"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Cross-profile calendar"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Show work events on your personal calendar"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"When work apps are off, they\'re paused and can\'t be accessed or send you notifications"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Manage storage"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"To help free up storage space, storage manager removes backed-up photos and videos from your device."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Remove photos and videos"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Storage manager"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Use storage manager"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestures"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Quickly open camera"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"To quickly open camera, press the power button twice. Works from any screen."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Flip camera for selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigation mode"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"2-button navigation"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"To switch apps, swipe up on the Home button. To see all apps, swipe up again. To go back, tap the back button."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Safety and emergency"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Emergency SOS, medical info, alerts"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Gesture navigation"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"To go home, swipe up from the bottom of the screen. To switch apps, swipe up from the bottom, hold, then release. To go back, swipe from either the left or right edge."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"3-button navigation"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Go back, home and switch apps with buttons at the bottom of your screen."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"system navigation, 2-button navigation, 3-button navigation, gesture navigation, swipe"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digital assistant"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Swipe to invoke the assistant"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Swipe up from the bottom corner to invoke digital assistant app."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Hold Home for Assistant"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Press and hold the Home button to invoke digital assistant app."</string>
    <string name="low_label" msgid="6525629096999711220">"Low"</string>
    <string name="high_label" msgid="357503396626018487">"High"</string>
    <string name="left_edge" msgid="1513576842959071849">"Left edge"</string>
    <string name="right_edge" msgid="1505309103265829121">"Right edge"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Higher sensitivity may conflict with any app gestures along the edges of the screen."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Back sensitivity"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Gesture navigation sensitivity"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Button navigation"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"gesture navigation, back sensitivity, back gesture"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigation, home button"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"One-handed mode"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Use one-handed mode"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"One-handed mode shortcut"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"reachability"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Swipe down to"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Use the shortcut to"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Pull down the top half of your screen so that it’s easier to reach with one hand"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"How to use one-handed mode"</b>\n" • Make sure that gesture navigation is selected in system navigation settings\n • Swipe down near the bottom edge of the screen"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Pull screen into reach"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"The top of the screen will move into reach of your thumb."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Show notifications"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Notifications and settings will appear."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"To check time, notifications and other info, double-tap your screen."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Wake up display"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"To check time, notifications and other info, tap your screen."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Emergency SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Use Emergency SOS"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Press the power button quickly five times or more to start the actions below"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Play countdown alarm"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Play a loud sound when Emergency SOS is starting"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Notify for help"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Call for help"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Number to call for help"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Tap to change"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"If you enter a non-emergency number:\n • Your device must be unlocked to use Emergency SOS\n • Your call may not be answered"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Swipe fingerprint for notifications"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Swipe fingerprint"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"See notifications quickly"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"On"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Off"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Bootloader is already unlocked"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Connect to the Internet or contact your operator"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Unavailable on mobile-locked devices"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Please restart the device to enable device protection feature."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> total made available\n\nLast ran on <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant Apps"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Open links in apps, even if they’re not installed"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant Apps"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Instant Apps preferences"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Installed apps"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Your storage is now being managed by the storage manager"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Accounts for <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automatically sync app data"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Let apps refresh data automatically"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Account sync"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sync on for <xliff:g id="ID_1">%1$d</xliff:g> of <xliff:g id="ID_2">%2$d</xliff:g> items"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sync on for all items"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sync off for all items"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Managed device info"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Changes &amp; settings managed by your organisation"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Changes &amp; settings managed by <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"To provide access to your work data, your organisation may change settings and install software on your device.\n\nFor more details, contact your organisation\'s admin."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Types of information that your organisation can see"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Changes made by your organisation\'s admin"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Your access to this device"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Data associated with your work account, such as email and calendar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"List of apps on your device"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Amount of time and data spent in each app"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Most recent network traffic log"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Most recent bug report"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Most recent security log"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"None"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Apps installed"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Number of apps is estimated. It may not include apps installed outside of the Play Store."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimum # app}other{Minimum # apps}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Location permissions"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Microphone permissions"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Camera permissions"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Default apps"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Default keyboard"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Set to <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Always-on VPN turned on"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Always-on VPN turned on in your personal profile"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Always-on VPN turned on in your work profile"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Global HTTP proxy set"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Trusted credentials"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Trusted credentials in your personal profile"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Trusted credentials in your work profile"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimum # CA certificate}other{Minimum # CA certificates}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Admin can lock the device and reset password"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Admin can delete all device data"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Failed password attempts before deleting all device data"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Failed password attempts before deleting work profile data"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# attempt}other{# attempts}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"This device is managed by your organisation."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"This device is managed by <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Learn more"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Restricted setting"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Restricted settings allowed for <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"For your security, this setting is currently unavailable."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Financed device info"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Your credit provider can change settings and install software on this device during setup.\n\nIf you miss a payment, your credit provider can lock your device and change device settings.\n\nTo learn more, contact your credit provider."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"If your device is financed, you can’t:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Install apps from outside the Play Store"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Reboot your device into safe mode"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Add multiple users to your device"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Change date, time and time zones"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Use Developer options"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Your credit provider can:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Access your IMEI number"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Factory reset your device if something goes wrong"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"If your device is locked, you can only use it to:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Make emergency calls"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"View system info, like date, time, network status and battery"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Turn your device on or off"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"View notifications and text messages"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Access apps that are allowed by the credit provider"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Once you pay the full amount:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"All restrictions are removed from the device"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"You can uninstall the creditor app"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Financed device info"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Camera app}other{Camera apps}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Calendar app"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Contacts app"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Email client app}other{Email client apps}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Map app"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Phone app}other{Phone apps}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"This device"</string>
    <string name="storage_games" msgid="1176568610086802469">"Games"</string>
    <string name="storage_files" msgid="7968460921272772299">"Files"</string>
    <string name="storage_images" msgid="2055893015567979387">"Images"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videos"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apps"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Documents and other"</string>
    <string name="storage_system" msgid="8472410119822911844">"System"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Bin"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Empty bin?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"There are <xliff:g id="TOTAL">%1$s</xliff:g> of files in the bin. All items will be deleted forever, and you won’t be able to restore them."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Bin is empty"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Empty bin"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> used"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> total"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Clear app"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Do you want to remove this instant app?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Open"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Games"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Space used"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(uninstalled for user <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(disabled for user <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Auto-fill service"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Default auto-fill service"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Passwords"</string>
    <!-- no translation found for credman_chosen_app_title (7735183808067729319) -->
    <skip />
    <string name="credman_credentials" msgid="4931371941253324143">"Additional providers"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# password}other{# passwords}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"auto, fill, autofill, password"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"data, passkey, password"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"auto, fill, autofill, data, passkey, password"</string>
    <!-- no translation found for credman_button_change (4072629639218503790) -->
    <skip />
    <!-- no translation found for credman_button_open (7519871964170816850) -->
    <skip />
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Make sure that you trust this app&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Auto-fill&gt;%1$s&lt;/xliff:g&gt; uses what\'s on your screen to determine what can be auto-filled."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Use &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; New passwords, passkeys and other info will be saved here from now on. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; may use what\'s on your screen to determine what can be autofilled."</string>
    <string name="credman_picker_title" msgid="8191267620665129205">"Passwords, passkeys and data services"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Turn off %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Turn off this service?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Saved info like passwords, passkeys, payment methods and other info won\'t be filled in when you sign in. To use your saved info, choose a password, passkey or data service."</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Turn off all services?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Passwords, passkeys and other saved info won\'t be available for autofill when you sign in"</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&lt;b&gt;Change your preferred service to &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; New passwords, passkeys and other info will be saved here from now on. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; may use what\'s on your screen to determine what can be autofilled"</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Use %1$s?"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"You can only have 5 services on"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Turn off at least 1 service to add another"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s uses what\'s on your screen to determine what can be auto-filled."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Passwords, passkeys and data services limit"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"You can have up to five passwords, passkeys and data services active at the same time. Turn off a service to add more."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Turn off"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Auto-fill"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Logging level"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Max requests per session"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Max visible datasets"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Reset to default values"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Auto-fill developer options have been reset"</string>
    <string name="location_category" msgid="3496759112306219062">"Location"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Status bar location indicator"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Show for all locations, including network and connectivity"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Force full GNSS measurements"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Track all GNSS constellations and frequencies with no duty cycling"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Input method"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Stylus handwriting"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"When enabled, the current input method receives a stylus MotionEvent if an Editor is focused."</string>
    <string name="device_theme" msgid="5027604586494772471">"Device theme"</string>
    <string name="default_theme" msgid="4815428567082263639">"Default"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Network name"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Display network name in status bar"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant app"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Turn off the storage manager?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Update Do Not Disturb"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pause notifications to stay focused"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Feature not available"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"This feature has been turned off because it slows down your phone"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Always show crash dialogue"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Show dialogue every time an app crashes"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Select ANGLE enabled app"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"No ANGLE enabled application set"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"ANGLE enabled application: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Graphics driver preferences"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Modify graphics driver settings"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"When there are multiple graphics drivers, you can pick to use the updated graphics driver for apps installed on the device."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Enable for all apps"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Select graphics driver"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Default"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Game driver"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Developer driver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"System graphics driver"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="enable_angle_as_system_driver" msgid="4648827560023949786">"Experimental: Enable ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Warning: Enable ANGLE as default OpenGL ES driver. This feature is experimental and may not be compatible with some camera and video apps."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"A reboot is required to change the system OpenGL ES driver"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"App compatibility changes"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Toggle app compatibility changes"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Default enabled changes"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Default disabled changes"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"App compatibility changes can only be modified for debuggable apps. Install a debuggable app and try again."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Depends on another setting"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Account"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"%d accounts"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Device name"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Basic info"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Legal and regulatory"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Device details"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Device identifiers"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Wi-Fi control"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Allow app to control Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Allow this app to turn Wi-Fi on or off, scan and connect to Wi-Fi networks, add or remove networks, or start a local-only hotspot"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Launch via NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Allow launch on NFC scan"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Allow this app to launch when an NFC tag is scanned.\nIf this permission is on, the app will be available as an option whenever a tag is detected."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Play media to"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Play <xliff:g id="LABEL">%s</xliff:g> on"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Audio will play on"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"This device"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Unavailable during calls"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Take call on"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"This APN cannot be changed."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Prevent ringing"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Press Power and Volume Up together to"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Shortcut to prevent ringing"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrate"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Mute"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrate"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Mute"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"To enable, first change \'Press &amp; hold power button\' to the power menu."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Network details"</string>
    <string name="devices_title" msgid="649715719278562515">"Devices"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Choose network"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Disconnected"</string>
    <string name="network_connected" msgid="7637745547242487795">"Connected"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Connecting…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Couldn’t connect"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"No networks found."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Couldn’t find networks. Try again."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(forbidden)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"No SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"None"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Requires SIM to connect"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Requires <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> SIM to connect"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Preferred network mode: WCDMA preferred"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Preferred network mode: GSM only"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Preferred network mode: WCDMA only"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Preferred network mode: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Preferred network mode: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Preferred network mode: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Preferred network mode: CDMA only"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Preferred network mode: EvDo only"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Preferred network mode: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Preferred network mode: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Preferred network mode: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Preferred network mode: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Preferred network mode: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Preferred network mode: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Preferred network mode: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Preferred network mode: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Preferred network mode: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Preferred network mode: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Preferred network mode: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Preferred network mode: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Preferred network mode: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Preferred network mode: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Preferred network mode: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Preferred network mode: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Preferred network mode: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Preferred network mode: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Preferred network mode: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Preferred network mode: NR only"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Preferred network mode: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Preferred network mode: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Preferred network mode: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Preferred network mode: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Preferred network mode: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Preferred network mode: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Preferred network mode: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Preferred network mode: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Preferred network mode: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Preferred network mode: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (recommended)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (recommended)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (recommended)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Automatically select network"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Operator settings"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Set up data service"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobile data"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Access data using mobile network"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Phone will automatically switch to this mobile operator when in range"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"No SIM available"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Calls preference"</string>
    <string name="sms_preference" msgid="7742964962568219351">"SMS preference"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Ask every time"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Add a network"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Default for calls"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Default for SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Default for calls &amp; SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Default for mobile data"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobile data active"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobile data off"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Available"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Add SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Active/SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inactive/SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Active/eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inactive/eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIM name and colour"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Name"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Colour (used by compatible apps)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Save"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Use this SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Off"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"To disable this SIM, remove the SIM card"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Tap to activate <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <!-- no translation found for mobile_network_erase_sim (5387971155494245850) -->
    <skip />
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Preferred network type"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Change the network operating mode"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Preferred network type"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Operator settings version"</string>
    <string name="call_category" msgid="641461844504128789">"Calling"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Operator video calling"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"System select"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Change the CDMA roaming mode"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"System select"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Network"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA subscription"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Change between RUIM/SIM and NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"subscription"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatic registration…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Allow data roaming?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Check with your network provider for pricing."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"App data usage"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Invalid network mode <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignore."</string>
    <!-- no translation found for satellite_setting_title (2543034229989047673) -->
    <skip />
    <!-- no translation found for satellite_setting_enabled_summary (3554127722727530845) -->
    <skip />
    <!-- no translation found for satellite_setting_disabled_summary (6789122487534159857) -->
    <skip />
    <!-- no translation found for keywords_satellite_setting (3312183289776517695) -->
    <skip />
    <!-- no translation found for category_name_about_satellite_messaging (3756205049485508340) -->
    <skip />
    <!-- no translation found for title_about_satellite_setting (9212860038048311345) -->
    <skip />
    <!-- no translation found for category_title_your_satellite_plan (3017895097366691841) -->
    <skip />
    <!-- no translation found for title_have_satellite_plan (2048372355699977947) -->
    <skip />
    <!-- no translation found for title_no_satellite_plan (2876056203035197505) -->
    <skip />
    <!-- no translation found for summary_add_satellite_setting (3815254731634052432) -->
    <skip />
    <!-- no translation found for category_name_how_it_works (585303230539269496) -->
    <skip />
    <!-- no translation found for title_satellite_connection_guide (3294802307913609072) -->
    <skip />
    <!-- no translation found for summary_satellite_connection_guide (3496123195218418456) -->
    <skip />
    <!-- no translation found for title_supported_service (4275535165812691571) -->
    <skip />
    <!-- no translation found for summary_supported_service (4320535903444834786) -->
    <skip />
    <!-- no translation found for satellite_setting_summary_more_information (4008690241760925372) -->
    <skip />
    <!-- no translation found for more_about_satellite_messaging (3385673133561348509) -->
    <skip />
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Access point names"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"APN"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Unavailable when connected to <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"See more"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Turn on <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Turn on SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Switch to <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Switch to using SIM card?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Use <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <!-- no translation found for sim_action_switch_sub_dialog_text (7474905814976249607) -->
    <skip />
    <!-- no translation found for sim_action_switch_sub_dialog_text_downloaded (6415848271400253954) -->
    <skip />
    <!-- no translation found for sim_action_switch_sub_dialog_text_single_sim (421658355882679837) -->
    <skip />
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"You can use two SIMs at a time. To use <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, turn off another SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Switch to <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Turn off <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Turning off a SIM won’t cancel your service"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Connecting to network…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Switching to <xliff:g id="CARRIER_NAME">%1$s</xliff:g> for calls and messages…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Can’t switch operator"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"The operator can’t be switched because of an error."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Turn off <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Turn off SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Turning off SIM<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Can’t disable operator"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Something went wrong and your operator could not be disabled."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Use two SIMs?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"This device can have two SIMs active at once. To continue using one SIM at a time, tap \'No, thanks\'."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Restart device?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Yes"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Restart"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"No, thanks"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Cancel"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Switch"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Turn off"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Can’t activate SIM"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Try turning on the SIM again. If the problem continues, restart your device."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"Set up your SIM"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Set your mobile network preferences to use multiple SIMs on this device"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"Label your SIMs"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"You’ll see these labels when making calls, sending texts and using data, and in Settings"</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"SIM label"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Label"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Select which SIMs to use"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"You can use two SIMs at a time"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Set your primary SIMs"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Choose which SIMs to use by default for calls, texts and data"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"Your primary SIMs"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Calls"</string>
    <string name="primary_sim_texts_title" msgid="1287584042733097749">"Texts"</string>
    <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatic data switching"</string>
    <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Use data from either SIM depending on coverage and availability"</string>
    <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data only"</string>
    <string name="sim_onboarding_setup" msgid="5750393553605388463">"Set up"</string>
    <string name="sim_onboarding_next" msgid="6415025179929475355">"Next"</string>
    <!-- no translation found for sim_onboarding_progressbar_turning_sim_on (1163318788393361574) -->
    <skip />
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Mobile network"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Phone number"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"SIM label and colour"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Network activation"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Operator switching"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> is active"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Tap to update SIM settings"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Switched to <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Switched to another operator"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Your mobile network has changed"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Set up your other SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Choose your active SIM or use two SIMs at once"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Choose a number to use"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{1 number is available on this device, but only one can be used at a time}=2{2 numbers are available on this device, but only one can be used at a time}other{# numbers are available on this device, but only one can be used at a time}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Activating<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Couldn’t be activated at the moment"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Use <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> will be used for mobile data, calls and SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"No active SIMs available"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"To use mobile data, call features and SMS at a later time, go to your network settings"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Erase this eSIM?"</string>
    <!-- no translation found for erase_sim_dialog_text (1406141218170595272) -->
    <skip />
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Erase"</string>
    <!-- no translation found for erasing_sim (4237180547590463930) -->
    <skip />
    <!-- no translation found for erase_sim_fail_title (1445700500168357303) -->
    <skip />
    <!-- no translation found for erase_sim_fail_text (6898841004987411547) -->
    <skip />
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Connect to device"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"<xliff:g id="APPNAME">%1$s</xliff:g> app wants to use a temporary Wi‑Fi network to connect to your device"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"No devices found. Make sure that devices are turned on and available to connect."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Try again"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Something came up. The application has cancelled the request to choose a device."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Connection successful"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Connection failed"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Show all"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Searching for device…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Connecting to device…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Left"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Right"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Case"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Settings Panel"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Force desktop mode"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Force experimental desktop mode on secondary displays"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Enable non-resizable in Multi-window"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Allows non-resizable apps to be in Multi-window"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Override force-dark"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Overrides the force-dark feature to be always on"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privacy"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Permissions, account activity, personal data"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Controls"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Remove"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Keep"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Remove this suggestion?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Storage is low. <xliff:g id="PERCENTAGE">%1$s</xliff:g> used – <xliff:g id="FREE_SPACE">%2$s</xliff:g> free"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Send feedback"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Would you like to give us feedback on this suggestion?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> copied to clipboard."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Accessibility usage"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 app has full access to your device}other{# apps have full access to your device}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Important information"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"CONTINUE"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NO, THANKS"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Location"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Your operator may collect your location when you use this service for emergency calls.\n\nVisit your operator\'s privacy policy for details."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"You may lose access to any remaining time or data. Check with your provider before removing."</string>
    <string name="content_capture" msgid="868372905432812238">"App content"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Allow apps to send content to the Android system"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Capture system heap dump"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Memory Tagging Extension (MTE) makes it easier to find memory safety issues in your app and make native code in it more secure."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Turning on MTE might cause slower device performance."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Learn more about MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Enable MTE until you turn it off"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"You\'ll need to restart your device to turn on MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"You\'ll need to restart your device to turn off MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Enable MTE for a single session"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"System will restart and allow experimenting with Memory Tagging Extension (MTE). MTE may negatively impact system performance and stability. Will be reset on next subsequent reboot."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Restart for a single session with MTE enabled"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE is already enabled"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Capturing system heap dump"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Couldn’t capture system heap dump"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automatically capture system heap dumps"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automatically capture a heap dump for Android System when it uses too much memory"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Disconnect"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Emergency calls"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Emergency calls over Wi‑Fi Calling are not supported by your operator.\nThe device switches automatically to a mobile network to place an emergency call.\nEmergency calls are only possible in areas with mobile coverage."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Use Wi‑Fi for calls to improve quality"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Incoming MMS message"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Can’t send MMS message"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Tap to allow MMS messaging on <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> when mobile data is off"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS message"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problem with SIM combination"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Using <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> may limit functionality. Tap to find out more."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM combination"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Your work policy info"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Settings managed by your IT admin"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Boot with 16K page size"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Boot device using 16K page size supported kernel"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Reboot with 16 KB pages compatible kernel?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"WARNING: Some applications may not be compatible with this mode. Device will reboot after confirmation."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Reboot with 4 KB pages compatible kernel?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"Device will reboot after confirmation."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Failed to update kernel to 16 KB pages compatible kernel."</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Applying change"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Bug report handler"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Determines which app handles the bug report shortcut on your device."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personal"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Work"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"System default"</string>
    <string name="default_app_none" msgid="5420632042222036264">"None"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"This choice is no longer valid. Try again."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Press and hold power button"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Press &amp; hold the power button to access"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Power menu"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digital assistant"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Access digital assistant"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Access power menu"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"To use, first set a screen lock"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Power menu:\nPress the power button and the volume up button at the same time"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Prevent ringing:\nPress a volume button for the shortcut"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Press &amp; hold duration"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Adjust sensitivity by choosing how long to press &amp; hold the power button"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Short"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Long"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Show wallet"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Allow access to wallet from lock screen"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Show QR code scanner"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Allow access to QR code scanner from lock screen"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Show device controls"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"From the lock screen"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Use device controls"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"To use, first turn on ‘Show device controls’"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Clock size changes according to lock screen content"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dynamic clock"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Shortcuts"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Turn off VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"This also turns off your 5G connection.\nDuring a voice call, you can’t use the Internet and some apps may not work."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspend execution for cached apps"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Never expires."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Lease never expires."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Allow screen overlays on settings"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Allow apps that can display over other apps to overlay settings screens"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Allow mock modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Allow this device to run mock modem service for instrumentation testing. Do not enable this during normal usage of the phone"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Media"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Pin media player"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"To quickly resume playback, media player stays open in Quick Settings"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Show media on lock screen"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"To quickly resume playback, media player stays open on lock screen"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Show Assistant media recommendations"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Based on your activity"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Hide player"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Show player"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"media"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth will turn on"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIMs"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Calls and SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Wi‑Fi calling"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Make and receive calls over Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Calls"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferred"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"preferred for calls"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"preferred for SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"unavailable"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Temporarily unavailable"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"No SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Network preferences"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"network connection, internet, wireless, data, wifi, wi-fi, wi fi, cellular, mobile, mobile operator, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Reset your Internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Resetting your Internet…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Fix connectivity"</string>
    <string name="networks_available" msgid="3299512933684383474">"Networks available"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"To switch networks, disconnect Ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ connections"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Allow Google Fi to use W+ networks to improve speed and coverage"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+ network"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIMs"</string>
    <!-- no translation found for sim_category_active_sim (3077009911935592178) -->
    <skip />
    <!-- no translation found for sim_category_inactive_sim (7351553344148400450) -->
    <skip />
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Default for <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"calls"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobile data"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"To improve device experience, apps and services can still scan for Wi‑Fi networks at any time, even when Wi‑Fi is off. This can be used, for example, to improve location-based features and services. You can change this in Wi‑Fi scanning settings."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Change"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g>/<xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Connected"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Temporarily connected"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Temporarily using <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"No connection"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobile data won\'t auto‑connect"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Turn off mobile data?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"You won\'t have access to data or the Internet through <xliff:g id="CARRIER">%s</xliff:g>. Internet will only be available via Wi‑Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"your operator"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Not allowed by your organisation"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Unavailable because bedtime mode is on"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Reset notification importance completed."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apps"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"A device wants to access your messages. Tap for details."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Allow access to messages?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"A Bluetooth device, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, wants to access your messages.\n\nYou haven’t connected to <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> before."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"A device wants to access your contacts and call log. Tap for details."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Allow access to contacts and call log?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"A Bluetooth device, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, wants to access your contacts and call log. This includes data about incoming and outgoing calls.\n\nYou haven’t connected to <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> before."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Brightness"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Lock display"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Appearance"</string>
    <string name="category_name_color" msgid="937514550918977151">"Colour"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Other display controls"</string>
    <string name="category_name_general" msgid="7737273712848115886">"General"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Use Dark theme"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Use Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Use prevent ringing"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Use Wi‑Fi hotspot"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Use app pinning"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Use Developer options"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Use print service"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Allow multiple users"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"allow, multiple, user, permit, many"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Use wireless debugging"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Use graphics driver preferences"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Use Night Light"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Use NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Use adaptive brightness"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Use Wi‑Fi calling"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"See all apps"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Smart forwarding"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Smart forwarding enabled"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Smart forwarding disabled"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Call settings"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Updating settings…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Call settings error"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Network or SIM error."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM is not activated."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Enter phone numbers"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Enter phone number"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Phone number is missing."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Allow 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G is less secure, but may improve your connection in some locations. For emergency calls, 2G is always allowed."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> requires 2G to be available"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Require encryption"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Encryption is more secure, but you might not be able to connect in some locations. For emergency calls, encryption is never required"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"All services"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Show clipboard access"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Show a message when apps access text, images or other content that you’ve copied"</string>
    <string name="all_apps" msgid="3054120149509114789">"All apps"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Don\'t allow"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra-wideband (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Helps identify the relative position of nearby devices that have UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Turn off aeroplane mode to use UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is unavailable in the current location"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Camera access"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Microphone access"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"For apps and services"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"For apps and services. If this setting is off, microphone data may still be shared when you call an emergency number."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Previous"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Next"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Colour preview"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"SIM access request"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"A device wants to access your SIM. Tap for details."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Allow access to SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"A Bluetooth device, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, wants to access data from your SIM. This includes your contacts.\n\nWhile connected, <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> will receive all calls made to <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Bluetooth device available"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"A device wants to connect. Tap for details."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Connect to Bluetooth device?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> wants to connect to this phone.\n\nYou haven’t connected to <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> before."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Don’t connect"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Connect"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE settings"</string>
    <string name="tare_on" msgid="2386073225978684535">"On"</string>
    <string name="tare_off" msgid="6305694402929756726">"Off"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Revert to default settings"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Settings reverted to default."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maximum satiated balance"</string>
    <string name="tare_balances" msgid="731881382594747961">"Balances"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Consumption limits"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Initial consumption limit"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimum consumption limit"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maximum consumption limit"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifiers"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Actions (cost to produce)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Actions (base price)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Rewards per single event"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Rewards per second of event duration"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maximum rewards per day"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"App install"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Top activity"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Notification seen"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Notification seen within 15 minutes"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Notification interaction"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Widget interaction"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Other user interaction"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Job max start"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Job max running"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Job high start"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Job high running"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Job default start"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Job default running"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Job low start"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Job low running"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Job min start"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Job min running"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Job timeout penalty"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimum satiated balance (exempted)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimum satiated balance (headless system app)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimum satiated balance (remaining apps)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Minimum satiated balance addition (app updaters)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Charging"</item>
    <item msgid="658627268149681677">"Doze"</item>
    <item msgid="1599558140284643834">"Power Save Mode"</item>
    <item msgid="588427840913221601">"Process state"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Confirm"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Preview"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Choose a screen saver"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Show additional information"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Display things like the time, weather or other information on the screen saver"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Show home controls"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Show home controls button from the screen saver"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"More settings"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Choose your screen saver"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Choose what you’ll see on your screen when your tablet is docked. Your device may use more energy when a screen saver is used."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Customise"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Customise <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"A reboot is required to enable freeform support."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"A reboot is required to force desktop mode on secondary displays."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Reboot now"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Reboot later"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Spatial Audio"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Audio from compatible media becomes more immersive"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Head tracking"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Audio changes as you move your head to sound more natural"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Sync permissions from phone"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Give your watch the same app permissions that you’ve allowed on this phone"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Audio Device Type"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Unknown"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Speaker"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Headphones"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Hearing Aid"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Car Kit"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Other"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Network download rate limit"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Configure the network bandwidth ingress rate limit which is applied to all networks that provide Internet connectivity."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Configure network download rate limit"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"No limit"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Disable child process restrictions"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Disable restrictions on the system resource usage of the app child processes"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Force enable Notes role"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Enable note-taking system integrations via the notes role. If the notes role is already enabled, does nothing. Requires reboot."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Broadcast"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Broadcast <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Listen to broadcasts that are playing near you"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Broadcast media to devices near you, or listen to someone else’s broadcast"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Broadcasts"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Listening to"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Find broadcasts"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Leave broadcast"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Scan QR code"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Enter password"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Can’t connect. Try again."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Wrong password"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Can’t join the broadcast"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"To start listening, centre the QR code below"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR code isn\'t a valid format"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Convert to eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transfer eSIM to another device"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Apps installed in the background"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Your device manufacturer may install apps on your device in the background, or allow your operator and other partners to do so.\n\nAny apps listed here aren\'t required for your device to function normally. You can uninstall apps that you don\'t want."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"No apps installed in the background"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Uninstall app"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Apps installed in the last # month}other{Apps installed in the last # months}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apps installed more than # month ago}other{Apps installed more than # months ago}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Aspect ratio"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Try a new aspect ratio to view this app if it hasn\'t been designed to fit your <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Try a new aspect ratio to view this app if it hasn\'t been designed to fit your <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Some apps may not be optimised for certain aspect ratios."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Try a new aspect ratio to view an app if it hasn\'t been designed to fit your <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Try a new aspect ratio to view an app if it hasn\'t been designed to fit your <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Some apps may not be optimised for certain aspect ratios."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Suggested apps"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Changed apps"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"App default"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Full-screen"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Half-screen"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Device aspect ratio"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g> by <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"The app will restart when you change the aspect ratio. You may lose unsaved changes. Some apps may not be optimised for certain aspect ratios."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Aspect ratio (experimental)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Aspect ratio (experiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Aspect ratio (labs)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Experimental"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Experiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Labs"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Fingerprint sensor"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Flash notifications"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"About flash notifications"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Off"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"On/Camera flash"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"On/Screen flash"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"On/Camera and screen flash"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Flash the camera light or the screen when you receive notifications or when alarms sound"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Flash the screen when you receive notifications or when alarms sound"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Use flash notifications with caution if you\'re light sensitive"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"flash, light, hard of hearing, hearing loss"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Preview"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Camera flash"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Screen flash"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Screen flash colour"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Blue"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azure"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cyan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Spring green"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Green"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Chartreuse green"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Yellow"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Orange"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Red"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Rose"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violet"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Done"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancel"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Contrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Medium"</string>
    <string name="contrast_high" msgid="3988567609694797696">"High"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"This app can only be opened in one window"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"On"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Off"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Off"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Off"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"On"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Off"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"On"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Off"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Turns light screens dark and dark screens light"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Zoom in on the screen"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Off"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Off"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"On"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Off"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"On"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Your device name is visible to apps you installed. It may also be seen by other people when you connect to Bluetooth devices, connect to a Wi-Fi network or set up a Wi-Fi hotspot."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Grammatical gender"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Select grammatical gender"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Scanning for deceptive apps"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Check app activity for phishing"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Use scanning for deceptive apps"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Use scanning for deceptive apps for work"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
    <string name="accessibility_setup_password_complete" msgid="6358749253318369077">"Password is now set up"</string>
</resources>
