<?xml version="1.0" encoding="UTF-8"?>
<!-- 
    Copyright 2018 The Android Open Source Project

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="settings_label" msgid="5147911978211079839">"Settings"</string>
    <string name="more_settings_label" msgid="3867559443480110616">"More"</string>
    <string name="display_settings" msgid="5325515247739279185">"Display"</string>
    <string name="brightness" msgid="2919605130898772866">"Brightness level"</string>
    <string name="auto_brightness_title" msgid="9124647862844666581">"Adaptive brightness"</string>
    <string name="auto_brightness_summary" msgid="4741887033140384352">"Optimise brightness level for available light"</string>
    <string name="condition_night_display_title" msgid="3777509730126972675">"Night Light is on"</string>
    <string name="keywords_display" msgid="3978416985146943922">"screen, touchscreen"</string>
    <string name="keywords_display_brightness_level" msgid="3956411572536209195">"dim screen, touchscreen, battery"</string>
    <string name="keywords_display_auto_brightness" msgid="2700310050333468752">"dim screen, touchscreen, battery"</string>
    <string name="keywords_display_night_display" msgid="2922294576679769957">"dim screen, night, tint"</string>
    <string name="night_mode_tile_label" msgid="6603597795502131664">"Night mode"</string>
    <string name="network_and_internet" msgid="4229023630498537530">"Network &amp; internet"</string>
    <string name="mobile_network_settings" msgid="1708621113321368597">"Mobile network"</string>
    <string name="mobile_network_toggle_title" msgid="3515647310810280063">"Mobile data"</string>
    <string name="mobile_network_toggle_summary" msgid="8698267487987697148">"Access data using mobile network"</string>
    <string name="confirm_mobile_data_disable" msgid="826493998804496639">"Turn off mobile data?"</string>
    <string name="data_usage_settings" msgid="7877132994777987848">"Data usage"</string>
    <string name="data_warning_limit_title" msgid="4950868241810828601">"Data warning limit"</string>
    <string name="app_usage_cycle" msgid="8445927080245880296">"App data usage cycle"</string>
    <string name="set_data_warning" msgid="6628236612886588097">"Set data warning"</string>
    <string name="data_warning" msgid="116776633806885370">"Data warning"</string>
    <string name="set_data_limit" msgid="7136539812414500084">"Set data limit"</string>
    <string name="data_limit" msgid="227338836292511425">"Data limit"</string>
    <string name="data_usage_limit_dialog_title" msgid="1864716658371721883">"Limiting data usage"</string>
    <string name="data_usage_limit_dialog_mobile" msgid="3633960011913085089">"Your vehicle’s head unit will turn off mobile data once it reaches the limit that you set.\n\nSince data usage is measured by the head unit, and your operator may account for usage differently, consider setting a conservative limit."</string>
    <string name="wifi_settings" msgid="7701477685273103841">"Wi‑Fi"</string>
    <string name="wifi_starting" msgid="473253087503153167">"Turning Wi‑Fi on…"</string>
    <string name="wifi_stopping" msgid="3534173972547890148">"Turning off Wi‑Fi…"</string>
    <string name="loading_wifi_list" msgid="8584901433195876465">"Loading Wi‑Fi list"</string>
    <string name="wifi_disabled" msgid="5013262438128749950">"Wi‑Fi disabled"</string>
    <string name="wifi_failed_forget_message" msgid="121732682699377206">"Failed to forget network"</string>
    <string name="wifi_failed_connect_message" msgid="4447498225022147324">"Failed to connect to network"</string>
    <string name="wifi_setup_add_network" msgid="3660498520389954620">"Add network"</string>
    <string name="wifi_setup_connect" msgid="3512399573397979101">"Connect"</string>
    <string name="wifi_password" msgid="5565632142720292397">"Password"</string>
    <string name="wifi_show_password" msgid="8423293211933521097">"Show password"</string>
    <string name="wifi_ssid" msgid="488604828159458741">"Network name"</string>
    <string name="wifi_ssid_hint" msgid="3170608752313710099">"Enter the SSID"</string>
    <string name="wifi_security" msgid="158358046038876532">"Security"</string>
    <string name="wifi_signal_strength" msgid="8507318230553042817">"Signal strength"</string>
    <string name="wifi_status" msgid="5688013206066543952">"Status"</string>
    <string name="wifi_speed" msgid="1650692446731850781">"Link speed"</string>
    <string name="wifi_frequency" msgid="8951455949682864922">"Frequency"</string>
    <string name="wifi_ip_address" msgid="3128140627890954061">"IP Address"</string>
    <string name="show_password" msgid="2074628020371139240">"Show password"</string>
    <string name="default_network_name_summary" msgid="8148402439232464276">"Enter network name"</string>
    <string name="default_password_summary" msgid="8789594645836902982">"Enter password"</string>
    <string name="access_point_tag_key" msgid="1517143378973053337">"access_point_tag_key"</string>
  <string-array name="wifi_signals">
    <item msgid="4897376984576812606">"Poor"</item>
    <item msgid="7683058295076342057">"Poor"</item>
    <item msgid="1639222824821660744">"Fair"</item>
    <item msgid="1838705897358163300">"Good"</item>
    <item msgid="6067166649320533751">"Excellent"</item>
  </string-array>
    <string name="link_speed" msgid="7868861844075624445">"%1$d Mbps"</string>
    <string name="wifi_band_24ghz" msgid="8972492390639295220">"2.4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="2023762623523105080">"5 GHz"</string>
    <string name="wifi_network_detail" msgid="9070182553555487360">"Network details"</string>
    <string name="wifi_mac_address" msgid="1466178247802349180">"MAC address"</string>
    <string name="wifi_ip_address_title" msgid="300539799594024884">"IP address"</string>
    <string name="wifi_subnet_mask" msgid="6238171812379380608">"Subnet mask"</string>
    <string name="wifi_dns" msgid="1841448353154932801">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="4707181386646531890">"IPv6 addresses"</string>
    <string name="wifi_gateway" msgid="4975799192860431013">"Gateway"</string>
    <string name="wifi_preferences_title" msgid="772788844257225510">"Wi‑Fi preferences"</string>
    <string name="wifi_wakeup" msgid="7451825226044542000">"Turn on Wi‑Fi automatically"</string>
    <string name="wifi_wakeup_summary" msgid="7237521683331291414">"Wi‑Fi will turn back on near high‑quality saved networks, such as your home network"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="2821576525488435259">"Unavailable because location is turned off. Turn on "<annotation id="link">"location"</annotation>"."</string>
    <string name="wifi_settings_scanning_required_title" msgid="2726782203331704928">"Turn on Wi‑Fi scanning?"</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="4464931023377210050">"Turn on"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5457372118991438313">"Wi‑Fi scanning turned on"</string>
    <string name="wifi_cellular_fallback_title" msgid="8322675436784870862">"Switch to mobile data automatically"</string>
    <string name="wifi_cellular_fallback_summary" msgid="2433848528924203758">"Use mobile data when Wi‑Fi has no Internet access. Data usage charges may apply."</string>
    <string name="learn_more" msgid="8214605928933358604">"Learn more"</string>
    <string name="bluetooth_settings_title" msgid="3794688574569688649">"Bluetooth"</string>
    <string name="bluetooth_device" msgid="3178478829314083240">"Unnamed device"</string>
    <string name="bluetooth_paired_devices" msgid="6463199569164652410">"Paired devices"</string>
    <string name="bluetooth_pair_new_device" msgid="6948753485443263095">"Pair new device"</string>
    <string name="bluetooth_pair_new_device_summary" msgid="2497221247690369031">"Bluetooth will turn on to pair"</string>
    <string name="bluetooth_disconnect_title" msgid="7675271355910637528">"Disconnect device?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="2017519733701757244">"Your vehicle will disconnect from <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_vehicle_mac_address" msgid="7069234636525805937">"Vehicle\'s Bluetooth address: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_device_mac_address" msgid="3949829271575045069">"Device\'s Bluetooth address: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_name" msgid="2609869978821094114">"Vehicle name"</string>
    <string name="bluetooth_rename_vehicle" msgid="5769424875066563154">"Rename this vehicle"</string>
    <string name="bluetooth_rename_device" msgid="8406868875363878712">"Rename device"</string>
    <string name="bluetooth_rename_button" msgid="2397892174725986383">"Rename"</string>
    <string name="bluetooth_available_devices" msgid="1854446368146061448">"Available devices"</string>
    <string name="bluetooth_profiles" msgid="5580372290862835951">"Profiles"</string>
    <string name="bluetooth_error_title" msgid="2341600997536511742"></string>
    <string name="bluetooth_notif_ticker" msgid="7192577740198156792">"Bluetooth pairing request"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="3138105800372470422">"Pair &amp; connect"</string>
    <string name="bluetooth_pairing_key_msg" msgid="5066825929751599037">"Bluetooth pairing code"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="1636575922217263060">"PIN contains letters or symbols"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5955236916732265593">"Type the pairing code then press Return or Enter"</string>
    <string name="bluetooth_pairing_request" msgid="4769675459526556801">"Pair with <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="2015966932886300630">"Allow <xliff:g id="DEVICE_NAME">%1$s</xliff:g> to access your contacts and call history"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="7825091249522704764">"You may also need to type this PIN on the other device."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="7147248221018865922">"You may also need to type this passkey on the other device."</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="418776900816984778">"Must be 16 digits"</string>
    <string name="bluetooth_pin_values_hint" msgid="1561325817559141687">"Usually 0000 or 1234"</string>
    <string name="bluetooth_notif_title" msgid="8374602799367803335">"Pairing request"</string>
    <string name="bluetooth_notif_message" msgid="1060821000510108726">"Tap to pair with <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="language_settings" msgid="2079258598337245546">"Languages"</string>
    <string name="languages_and_input_settings" msgid="3672322610529408248">"Languages &amp; input"</string>
    <string name="keyboard_settings" msgid="1959697870618278081">"Keyboard"</string>
    <string name="manage_keyboard" msgid="4045394766282200132">"Manage keyboards"</string>
    <string name="text_to_speech_settings" msgid="811985746199507343">"Text to speech output"</string>
    <string name="text_to_speech_preferred_engine_settings" msgid="2766782925699132256">"Preferred engine"</string>
    <string name="text_to_speech_current_engine" msgid="8133107484909612597">"Current engine"</string>
    <string name="tts_speech_rate" msgid="4512944877291943133">"Speech Rate"</string>
    <string name="tts_pitch" msgid="2389171233852604923">"Pitch"</string>
    <string name="tts_reset" msgid="6289481549801844709">"Reset"</string>
    <string name="sound_settings" msgid="3072423952331872246">"Sound"</string>
    <string name="ring_volume_title" msgid="3135241004980719442">"Ring volume"</string>
    <string name="navi_volume_title" msgid="946292066759195165">"Navigation volume"</string>
    <string name="incoming_call_volume_title" msgid="6972117872424656876">"Ring tone"</string>
    <string name="notification_volume_title" msgid="6749411263197157876">"Notification"</string>
    <string name="media_volume_title" msgid="6697416686272606865">"Media"</string>
    <string name="media_volume_summary" msgid="2961762827637127239">"Set volume for music and videos"</string>
    <string name="alarm_volume_title" msgid="840384014895796587">"Alarm"</string>
    <string name="ringtone_title" msgid="8370531086214517972">"Phone ringtone"</string>
    <string name="notification_ringtone_title" msgid="8661716239594010288">"Default notification sound"</string>
    <string name="alarm_ringtone_title" msgid="3257364170646440908">"Default alarm sound"</string>
    <string name="apps_and_notifications_settings" msgid="8704585874333781975">"Apps &amp; notifications"</string>
    <string name="all_applications" msgid="7798210477486822168">"Show all apps"</string>
    <string name="default_applications" msgid="1558183275638697087">"Default apps"</string>
    <string name="applications_settings" msgid="794261395191035632">"App info"</string>
    <string name="force_stop" msgid="2153183697014720520">"Force stop"</string>
    <string name="force_stop_dialog_title" msgid="3342850939200388694">"Force stop?"</string>
    <string name="force_stop_dialog_text" msgid="4354954014318432599">"If you force-stop an app, it may misbehave."</string>
    <string name="disable_text" msgid="4358165448648990820">"Disable"</string>
    <string name="enable_text" msgid="1794971777861881238">"Enable"</string>
    <string name="uninstall_text" msgid="277907956072833012">"Uninstall"</string>
    <string name="app_disable_dialog_text" msgid="7731155411006654025">"If you disable this app, Android and other apps may no longer function as intended."</string>
    <string name="app_disable_dialog_positive" msgid="4448684722791563349">"Disable app"</string>
    <string name="permissions_label" msgid="2701446753515612685">"Permission"</string>
    <string name="application_version_label" msgid="8556889839783311649">"Version: %1$s"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="6001439205270250021">"No permissions granted"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="4074220596273432442">"No permissions requested"</string>
    <string name="data_usage_summary_title" msgid="4368024763485916986">"Data usage"</string>
    <string name="data_usage_app_summary_title" msgid="5012851696585421420">"App data usage"</string>
    <string name="computing_size" msgid="5791407621793083965">"Computing…"</string>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="3513360187065317613">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> additional permissions</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> additional permission</item>
    </plurals>
    <string name="assist_and_voice_input_settings" msgid="8813195157136637132">"Assist &amp; voice input"</string>
    <string name="assist_app_settings" msgid="9085261410166776497">"Assist app"</string>
    <string name="assist_access_context_title" msgid="8034851731390785301">"Use text from screen"</string>
    <string name="assist_access_context_summary" msgid="2374281280599443774">"Allow the assist app to access the screen contents as text"</string>
    <string name="assist_access_screenshot_title" msgid="2855956879971465044">"Use screenshot"</string>
    <string name="assist_access_screenshot_summary" msgid="6246496926635145782">"Allow the assist app to access an image of the screen"</string>
    <!-- no translation found for voice_input_settings_title (3238707827815647526) -->
    <skip />
    <string name="autofill_settings_title" msgid="1188754272680049972">"Auto-fill service"</string>
    <string name="app_list_preference_none" msgid="7753357799926715901">"None"</string>
    <string name="default_app_selected_app" msgid="5289396663745484773">"Selected"</string>
    <string name="assistant_security_warning" msgid="1844807956967428012">"The assistant will be able to read information about apps that are in use on your system, including information visible on your screen or accessible within the apps."</string>
    <string name="autofill_confirmation_message" msgid="1832984461556991378">"&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="autofill_add_service" msgid="6413893366443609951">"Add service"</string>
    <string name="location_settings_title" msgid="901334356682423679">"Location"</string>
    <string name="location_settings_recent_requests_title" msgid="6345634382240930628">"Recent Location Requests"</string>
    <string name="location_settings_recent_requests_empty_message" msgid="7789667070033674910">"No recent location requests"</string>
    <string name="location_settings_app_permissions_title" msgid="6446735313354321564">"App-level permissions"</string>
    <string name="location_settings_scanning_title" msgid="4253945869911300740">"Scanning"</string>
    <string name="location_settings_services_title" msgid="1186133632690970468">"Location Services"</string>
    <string name="location_settings_wifi_scanning_title" msgid="8021558840074023719">"Wi‑Fi scanning"</string>
    <string name="location_settings_wifi_scanning_summary" msgid="2116283960258671324">"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_settings_bluetooth_scanning_title" msgid="2969682902241932059">"Bluetooth scanning"</string>
    <string name="location_settings_bluetooth_scanning_summary" msgid="9158101751700727062">"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="system_setting_title" msgid="6864599341809463440">"System"</string>
    <string name="system_update_settings_title" msgid="8448588267784138855">"System updates"</string>
    <string name="firmware_version" msgid="8491753744549309333">"Android version"</string>
    <string name="security_patch" msgid="4794276590178386903">"Android security patch level"</string>
    <string name="model_info" msgid="4966408071657934452">"Model"</string>
    <string name="baseband_version" msgid="2370088062235041897">"Baseband version"</string>
    <string name="kernel_version" msgid="7327212934187011508">"Kernel version"</string>
    <string name="build_number" msgid="3997326631001009102">"Build number"</string>
    <string name="bluetooth_mac_address" msgid="7641425947941688072">"Bluetooth address"</string>
    <string name="device_info_not_available" msgid="2095601973977376655">"Not available"</string>
    <string name="device_status_activity_title" msgid="4083567497305368200">"Status"</string>
    <string name="device_status" msgid="267298179806290920">"Status"</string>
    <string name="device_status_summary" product="tablet" msgid="600543254608862075">"Status of the battery, network and other information"</string>
    <string name="device_status_summary" product="default" msgid="9130360324418117815">"Phone number, signal, etc."</string>
    <string name="about_settings" msgid="4329457966672592345">"About"</string>
    <string name="about_summary" msgid="5374623866267691206">"Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="about_settings_summary" msgid="7975072809083281401">"View legal info, status, software version"</string>
    <string name="legal_information" msgid="1838443759229784762">"Legal information"</string>
    <string name="contributors_title" msgid="7698463793409916113">"Contributors"</string>
    <string name="manual" msgid="4819839169843240804">"Manual"</string>
    <string name="regulatory_labels" msgid="3165587388499646779">"Regulatory labels"</string>
    <string name="safety_and_regulatory_info" msgid="1204127697132067734">"Safety &amp; regulatory manual"</string>
    <string name="copyright_title" msgid="4220237202917417876">"Copyright"</string>
    <string name="license_title" msgid="936705938435249965">"Licence"</string>
    <string name="terms_title" msgid="5201471373602628765">"Terms and conditions"</string>
    <string name="webview_license_title" msgid="6442372337052056463">"System WebView licences"</string>
    <string name="wallpaper_attributions" msgid="9201272150014500697">"Wallpaper"</string>
    <string name="wallpaper_attributions_values" msgid="4292446851583307603">"Satellite imagery providers:\n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_license_activity_title" msgid="8499293744313077709">"Third-party licences"</string>
    <string name="settings_license_activity_unavailable" msgid="6104592821991010350">"There is a problem loading the licences."</string>
    <string name="settings_license_activity_loading" msgid="6163263123009681841">"Loading…"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="2968627665608969405">
      <item quantity="other">You are now <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> steps away from being a developer.</item>
      <item quantity="one">You are now <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> step away from being a developer.</item>
    </plurals>
    <string name="show_dev_on" msgid="5339077400040834808">"You are now a developer!"</string>
    <string name="show_dev_already" msgid="1678087328973865736">"No need, you are already a developer."</string>
    <string name="developer_options_settings" msgid="1530739225109118480">"Developer options"</string>
    <string name="reset_options_title" msgid="4388902952861833420">"Reset options"</string>
    <string name="reset_options_summary" msgid="5508201367420359293">"Network, apps or device reset"</string>
    <string name="reset_network_title" msgid="1284233059990797263">"Reset network"</string>
    <string name="reset_network_desc" msgid="602381374544634925">"This will reset all network settings, including:"</string>
    <string name="reset_network_item_wifi" msgid="7569481589699982698"><li>"Wi‑Fi"</li></string>
    <string name="reset_network_item_mobile" msgid="5747282716664480997"><li>"Mobile data"</li></string>
    <string name="reset_network_item_bluetooth" msgid="6035019931106921284"><li>"Bluetooth"</li></string>
    <string name="reset_esim_title" msgid="8132107637911831211">"Erase all vehicle eSIMs"</string>
    <string name="reset_esim_desc" msgid="1437276625485586740">"This will not cancel your service plan."</string>
    <string name="reset_esim_error_title" msgid="7245109418130525492">"Can’t reset eSIMs"</string>
    <string name="reset_network_select" msgid="2433825874868038739">"Select network"</string>
    <string name="reset_network_button_text" msgid="8374174455632765033">"Reset settings"</string>
    <string name="reset_network_confirm_title" msgid="5255502723840197663">"Reset?"</string>
    <string name="reset_network_confirm_desc" msgid="7721698076856330212">"Reset all network settings? You can\'t undo this action!"</string>
    <string name="reset_network_confirm_button_text" msgid="5246859685069024851">"Reset settings"</string>
    <string name="reset_network_complete_toast" msgid="3804108209431416865">"Network settings have been reset"</string>
    <string name="reset_app_pref_title" msgid="5855420038951743992">"Reset app preferences"</string>
    <string name="reset_app_pref_desc" msgid="579392665146962149">"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\n"You will not lose any app data."</string>
    <string name="reset_app_pref_button_text" msgid="6270820447321231609">"Reset apps"</string>
    <string name="reset_app_pref_complete_toast" msgid="8709072932243594166">"App preferences have been reset"</string>
    <string name="master_clear_title" msgid="8515335233363214414">"Erase all data (factory reset)"</string>
    <string name="master_clear_desc" msgid="9058719802779893535">"This will erase all data from your vehicle’s head unit, including:\n\n"<li>"Your Google Account"</li>\n<li>"System and app data and settings"</li>\n<li>"Downloaded apps"</li></string>
    <string name="master_clear_accounts" msgid="7797522012993567494">"You are currently signed in to the following accounts:"</string>
    <string name="master_clear_other_users_present" msgid="8383376863095743337">"There are other users present on this vehicle."</string>
    <string name="master_clear_button_text" msgid="8010754220392741160">"Reset vehicle"</string>
    <string name="master_clear_confirm_title" msgid="8646455623132887370">"Reset?"</string>
    <string name="master_clear_confirm_desc" msgid="8920446291698038558">"Erase all your personal information and downloaded apps? You can\'t undo this action!"</string>
    <string name="master_clear_confirm_button_text" msgid="7981254968588121786">"Erase everything"</string>
    <string name="master_clear_progress_title" msgid="7087480656932674774">"Erasing"</string>
    <string name="master_clear_progress_text" msgid="3440789441935303176">"Please wait..."</string>
    <string name="date_and_time_settings_title" msgid="4058492663544475485">"Date &amp; time"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="7580119979694174107">"Set date and time"</string>
    <string name="date_and_time_settings_summary" msgid="7669856855390804666">"Set date, time, time zone, &amp; formats"</string>
    <string name="date_time_auto" msgid="3570339569471779767">"Automatic date &amp; time"</string>
    <string name="date_time_auto_summary" msgid="3311706425095342759">"Use network-provided time"</string>
    <string name="zone_auto" msgid="3701878581920206160">"Automatic time zone"</string>
    <string name="zone_auto_summary" msgid="4345856882906981864">"Use network-provided time zone"</string>
    <string name="date_time_24hour_title" msgid="3025576547136168692">"24‑hour format"</string>
    <string name="date_time_24hour" msgid="1137618702556486913">"Use 24-hour format"</string>
    <string name="date_time_set_time_title" msgid="5884883050656937853">"Time"</string>
    <string name="date_time_set_time" msgid="6449555153906058248">"Set time"</string>
    <string name="date_time_set_timezone_title" msgid="3001779256157093425">"Time zone"</string>
    <string name="date_time_set_timezone" msgid="4759353576185916944">"Select time zone"</string>
    <string name="date_time_set_date_title" msgid="6834785820357051138">"Date"</string>
    <string name="date_time_set_date" msgid="2537494485643283230">"Set date"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="7041628618528523514">"Sort alphabetically"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="4944880536057914136">"Sort by time zone"</string>
    <string name="date_picker_title" msgid="1533614225273770178">"Date"</string>
    <string name="time_picker_title" msgid="7436045944320504639">"Time"</string>
    <string name="user_admin" msgid="1535484812908584809">"Admin"</string>
    <string name="signed_in_admin_user" msgid="1267225622818673274">"Signed in as admin"</string>
    <string name="grant_admin_permissions_title" msgid="4628430467359951437">"All admin permissions"</string>
    <string name="grant_admin_permissions_button_text" msgid="988239414372882401">"Make admin"</string>
    <string name="grant_admin_permissions_message" msgid="1751910369004774830">"The user will be able to delete users, including other admins, and factory reset the system."</string>
    <string name="action_not_reversible_message" msgid="740401337875726973">"This action is not reversible."</string>
    <string name="confirm_grant_admin" msgid="7852596890218647682">"Yes, make admin"</string>
    <string name="create_user_permission_title" msgid="7781550880565935298">"Create new users"</string>
    <string name="outgoing_calls_permission_title" msgid="1230180443712099293">"Make phone calls"</string>
    <string name="sms_messaging_permission_title" msgid="6099328509729071243">"Messaging via car\'s mobile data"</string>
    <string name="install_apps_permission_title" msgid="3099705360827925296">"Install new apps"</string>
    <string name="uninstall_apps_permission_title" msgid="8448422340567430659">"Uninstall apps"</string>
    <string name="user_add_user_menu" msgid="5319151436895941496">"Add user"</string>
    <string name="user_new_user_name" msgid="7115771396412339662">"New user"</string>
    <string name="user_add_user_title" msgid="7458813670614932479">"Add new user?"</string>
    <string name="user_add_user_message_setup" msgid="6030901156040053106">"When you add a new user, that person needs to set up their space."</string>
    <string name="user_add_user_message_update" msgid="1528170913388932459">"Any user can update apps for all other users."</string>
    <string name="user_limit_reached_title" msgid="8803355734556061238">"User limit reached"</string>
    <plurals name="user_limit_reached_message" formatted="false" msgid="2651922256448824747">
      <item quantity="other">You can create up to <xliff:g id="COUNT">%d</xliff:g> users.</item>
      <item quantity="one">Only one user can be created.</item>
    </plurals>
    <string name="add_user_error_title" msgid="3206300411663817038">"Failed to create a new user"</string>
    <string name="delete_user_dialog_title" msgid="3422867434431562007">"Delete this user?"</string>
    <string name="delete_user_dialog_message" msgid="4346777604351785057">"All apps and data will be deleted."</string>
    <string name="delete_user_error_title" msgid="7609819398530124827">"Failed to delete user."</string>
    <string name="delete_user_error_dismiss" msgid="429156446763738273">"Dismiss"</string>
    <string name="delete_user_error_retry" msgid="5116434895572670563">"Retry"</string>
    <string name="delete_last_user_dialog_title" msgid="3644392025675369680">"Delete last user?"</string>
    <string name="delete_last_user_admin_created_message" msgid="1856897729010319054">"After deleting the only remaining user for this car, a new admin user will be created."</string>
    <string name="delete_last_user_system_setup_required_message" msgid="8550730509371697989">"All data, settings and apps associated with this user will be deleted. You\'ll need to set up the system again."</string>
    <string name="choose_new_admin_title" msgid="1915428454917699587">"Choose new admin"</string>
    <string name="choose_new_admin_message" msgid="7468286545352043354">"You need at least one admin. To delete this one, choose a replacement first."</string>
    <string name="choose_new_admin_label" msgid="5987653639387437939">"Choose admin"</string>
    <string name="user_guest" msgid="3465399481257448601">"Guest"</string>
    <string name="start_guest_session" msgid="4438752398760283201">"Guest"</string>
    <string name="user_switch" msgid="6544839750534690781">"Switch"</string>
    <string name="current_user_name" msgid="3813671533249316823">"You (%1$s)"</string>
    <string name="user_name_label" msgid="3210832645046206845">"Name"</string>
    <string name="user_summary_not_set_up" msgid="1473688119241224145">"Not set up"</string>
    <string name="edit_user_name_title" msgid="6890782937520262478">"Edit user name"</string>
    <string name="users_list_title" msgid="770764290290240909">"Users"</string>
    <string name="user_details_admin_title" msgid="3530292857178371891">"Permissions granted to %1$s"</string>
    <string name="accounts_settings_title" msgid="436190037084293471">"Accounts"</string>
    <string name="user_add_account_menu" msgid="6625351983590713721">"Add account"</string>
    <string name="no_accounts_added" msgid="5148163140691096055">"No accounts added"</string>
    <string name="account_list_title" msgid="7631588514613843065">"Accounts for <xliff:g id="CURRENT_USER_NAME">%1$s</xliff:g>"</string>
    <string name="account_auto_sync_title" msgid="3238816995364191432">"Automatically sync data"</string>
    <string name="account_auto_sync_summary" msgid="6963837893148304128">"Let apps refresh data automatically"</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="6027487764261344033">"Turn auto-sync data on?"</string>
    <string name="data_usage_auto_sync_on_dialog" msgid="2770233931307606956">"Any changes that you make to your accounts on the web will be automatically copied to your device.\n\nSome accounts may also automatically copy any changes that you make on the phone to the web. A Google Account works this way."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1235955038330202536">"Turn auto-sync data off?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="5040873073016183315">"This will conserve data, 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="account_details_title" msgid="7529571432258448573">"Account info"</string>
    <string name="add_account_title" msgid="5988746086885210040">"Add account"</string>
    <string name="add_an_account" msgid="1072285034300995091">"Add an account."</string>
    <string name="user_cannot_add_accounts_message" msgid="6775605884544906797">"Restricted profiles cannot add accounts"</string>
    <string name="remove_account_title" msgid="8840386525787836381">"Remove account"</string>
    <string name="really_remove_account_title" msgid="3555164432587924900">"Remove account?"</string>
    <string name="really_remove_account_message" msgid="4296769280849579900">"Removing this account will delete all of its messages, contacts and other data from the device!"</string>
    <string name="remove_account_error_title" msgid="8368044943174826635">"Failed to remove account."</string>
    <string name="account_sync_title" msgid="6541844336300236915">"Account sync"</string>
    <string name="account_sync_summary_some_on" msgid="4525960296068027182">"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="3652264471870312725">"Sync on for all items"</string>
    <string name="account_sync_summary_all_off" msgid="6550959714035312414">"Sync off for all items"</string>
    <string name="sync_disabled" msgid="393531064334628258">"Sync is OFF"</string>
    <string name="sync_error" msgid="6698021343089247914">"Sync error"</string>
    <string name="last_synced" msgid="4745124489150101529">"Last synced <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="1237573373537382416">"Syncing now…"</string>
    <string name="sync_one_time_sync" msgid="491707183321353107">"Tap to sync now<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_button_sync_now" msgid="5767643057970371315">"Sync now"</string>
    <string name="sync_button_sync_cancel" msgid="7739510554513641393">"Cancel sync"</string>
    <string name="sync_is_failing" msgid="5766255460901806206">"Sync is currently experiencing problems. It will be back shortly."</string>
    <string name="security_settings_title" msgid="6955331714774709746">"Security"</string>
    <string name="security_settings_subtitle" msgid="2244635550239273229">"Screen lock"</string>
    <string name="security_lock_none" msgid="1054645093754839638">"None"</string>
    <string name="security_lock_pattern" msgid="1174352995619563104">"Pattern"</string>
    <string name="security_lock_pin" msgid="4891899974369503200">"PIN"</string>
    <string name="security_lock_password" msgid="4420203740048322494">"Password"</string>
    <string name="lock_settings_picker_title" msgid="6590330165050361632">"Choose a lock type"</string>
    <string name="screen_lock_options" msgid="8531177937577168185">"Lock options"</string>
    <string name="lock_settings_enter_pattern" msgid="4826034565853171624">"Enter your pattern"</string>
    <string name="lockpattern_confirm_button_text" msgid="7784925958324484965">"Confirm"</string>
    <string name="lockpattern_restart_button_text" msgid="9355771277617537">"Redraw"</string>
    <string name="continue_button_text" msgid="5129979170426836641">"Continue"</string>
    <string name="lockscreen_retry_button_text" msgid="5314212350698701242">"Retry"</string>
    <string name="lockscreen_skip_button_text" msgid="3755748786396198091">"Skip"</string>
    <string name="set_screen_lock" msgid="5239317292691332780">"Set a screen lock"</string>
    <string name="lockscreen_choose_your_pin" msgid="1645229555410061526">"Choose your PIN"</string>
    <string name="lockscreen_choose_your_pattern" msgid="6801175111142593404">"Choose your pattern"</string>
    <string name="lockscreen_choose_your_password" msgid="4487577710136014069">"Choose your password"</string>
    <string name="current_screen_lock" msgid="637651611145979587">"Current screen lock"</string>
    <string name="choose_lock_pattern_message" msgid="6242765203541309524">"For security, set a pattern"</string>
    <string name="lockpattern_retry_button_text" msgid="4655398824001857843">"Clear"</string>
    <string name="lockpattern_cancel_button_text" msgid="4068764595622381766">"Cancel"</string>
    <string name="lockpattern_pattern_confirmed" msgid="5984306638250515385">"Your new unlock pattern"</string>
    <string name="lockpattern_recording_intro_header" msgid="7864149726033694408">"Draw an unlock pattern"</string>
    <string name="lockpattern_recording_inprogress" msgid="1575019990484725964">"Release finger when you\'ve finished"</string>
    <string name="lockpattern_pattern_entered" msgid="6103071005285320575">"Pattern recorded"</string>
    <string name="lockpattern_need_to_confirm" msgid="4648070076022940382">"Draw pattern again to confirm"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="2417932185815083082">"Connect at least four dots. Try again."</string>
    <string name="lockpattern_pattern_wrong" msgid="929223969555399363">"Wrong pattern"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="4436556875843192284">"How to draw an unlock pattern"</string>
    <string name="error_saving_lockpattern" msgid="2933512812768570130">"Error saving pattern"</string>
    <string name="okay" msgid="4589873324439764349">"OK"</string>
    <string name="remove_screen_lock_title" msgid="1234382338764193387">"Remove screen lock?"</string>
    <string name="remove_screen_lock_message" msgid="6675850371585564965">"This will allow anyone to access your account"</string>
    <string name="lock_settings_enter_pin" msgid="1669172111244633904">"Enter your PIN"</string>
    <string name="lock_settings_enter_password" msgid="2636669926649496367">"Enter your password"</string>
    <string name="choose_lock_pin_message" msgid="2963792070267774417">"For security, set a PIN"</string>
    <string name="confirm_your_pin_header" msgid="9096581288537156102">"Re-enter your PIN"</string>
    <string name="choose_lock_pin_hints" msgid="7362906249992020844">"PIN must be at least 4 digits"</string>
    <string name="lockpin_invalid_pin" msgid="2149191577096327424">"PIN invalid. Must be at least 4 digits."</string>
    <string name="confirm_pins_dont_match" msgid="4607110139373520720">"PINs don\'t match"</string>
    <string name="error_saving_lockpin" msgid="9011960139736000393">"Error saving PIN"</string>
    <string name="lockscreen_wrong_pin" msgid="4922465731473805306">"Wrong PIN"</string>
    <string name="lockscreen_wrong_password" msgid="5757087577162231825">"Wrong password"</string>
    <string name="choose_lock_password_message" msgid="6124341145027370784">"For security, set a password"</string>
    <string name="confirm_your_password_header" msgid="7052891840366724938">"Re-enter your password"</string>
    <string name="confirm_passwords_dont_match" msgid="7300229965206501753">"Passwords don\'t match"</string>
    <string name="lockpassword_clear_label" msgid="6363680971025188064">"Clear"</string>
    <string name="lockpassword_cancel_label" msgid="5791237697404166450">"Cancel"</string>
    <string name="lockpassword_confirm_label" msgid="5918463281546146953">"Confirm"</string>
    <string name="choose_lock_password_hints" msgid="3903696950202491593">"Must be at least four characters"</string>
    <string name="lockpassword_password_too_short" msgid="6681218025001328405">"Must be at least <xliff:g id="COUNT">%d</xliff:g> characters"</string>
    <string name="lockpassword_pin_too_short" msgid="6363004004424904218">"PIN must be at least <xliff:g id="COUNT">%d</xliff:g> digits"</string>
    <string name="lockpassword_password_too_long" msgid="7530214940279491291">"Must be fewer than <xliff:g id="NUMBER">%d</xliff:g> characters"</string>
    <string name="lockpassword_pin_too_long" msgid="62957683396974404">"Must be fewer than <xliff:g id="NUMBER">%d</xliff:g> digits"</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="3044526271686839923">"Must contain only digits 0-9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7901918311213276207">"Device admin doesn\'t allow using a recent PIN"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="7412709707800738442">"Common PINs are blocked by your IT admin. Try a different PIN."</string>
    <string name="lockpassword_illegal_character" msgid="1984970060523635618">"This can\'t include an invalid character."</string>
    <string name="lockpassword_invalid_password" msgid="1690956113717418430">"Password invalid. Must be at least four characters."</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="424616259312760303">
      <item quantity="other">Must contain at least <xliff:g id="COUNT">%d</xliff:g> letters</item>
      <item quantity="one">Must contain at least one letter</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2267487180744744833">
      <item quantity="other">Must contain at least <xliff:g id="COUNT">%d</xliff:g> lowercase letters</item>
      <item quantity="one">Must contain at least one lowercase letter</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="7999264563026517898">
      <item quantity="other">Must contain at least <xliff:g id="COUNT">%d</xliff:g> uppercase letters</item>
      <item quantity="one">Must contain at least 1 uppercase letter</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="7935079851855168646">
      <item quantity="other">Must contain at least <xliff:g id="COUNT">%d</xliff:g> numerical digits</item>
      <item quantity="one">Must contain at least 1 numerical digit</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="3994046435150094132">
      <item quantity="other">Must contain at least <xliff:g id="COUNT">%d</xliff:g> special symbols</item>
      <item quantity="one">Must contain at least 1 special symbol</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="6878486326748506524">
      <item quantity="other">Must contain at least <xliff:g id="COUNT">%d</xliff:g> non-letter characters</item>
      <item quantity="one">Must contain at least 1 non-letter character</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="8255729487108602924">"Device admin doesn\'t allow using a recent password"</string>
    <string name="error_saving_password" msgid="8334882262622500658">"Error saving password"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="7965893810326503891">"Common passwords are blocked by your IT admin. Try a different password."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="38813552228809240">"Ascending, descending or repeated sequence of digits isn\'t allowed."</string>
    <string name="setup_lock_settings_options_button_label" msgid="3337845811029780896">"Screen lock options"</string>
    <string name="build_info_fmt" msgid="5592554123908086426">"<xliff:g id="FINGERPRINT">%1$s</xliff:g>\n<xliff:g id="DATE">%2$s</xliff:g> : <xliff:g id="NUM_DAYS">%3$s</xliff:g> days ago"</string>
    <string name="add_device_title" msgid="8452168024017866232">"Add trusted device"</string>
    <string name="trusted_device" msgid="5637378361866787603">"Trusted devices"</string>
    <plurals name="trusted_device_subtitle" formatted="false" msgid="462041049834264945">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> devices</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> device</item>
    </plurals>
    <string name="remove_device_message" msgid="6447820559674148349">"Your <xliff:g id="CONNECTED_DEVICE_NAME_0">%1$s</xliff:g> will unlock this car when it\'s connected. If someone takes your <xliff:g id="CONNECTED_DEVICE_NAME_1">%1$s</xliff:g>, they may be able to access this device"</string>
    <string name="trusted_device_confirm_button" msgid="102354635014627996">"Confirm"</string>
    <string name="trusted_device_remove_button" msgid="6140476996063415420">"Remove trusted device"</string>
    <string name="trusted_device_done_button" msgid="8481956533222625296">"Done"</string>
    <string name="add_trusted_device_instruction" msgid="109228038968439923">"Use the companion app to set up a trusted device. Once set up, you will be able to unlock your user profile when your phone is detected by the vehicle"</string>
    <string name="trusted_device_download_app" msgid="6971096140154499983">"1. Download the companion app on your phone"</string>
    <string name="trusted_device_select_device" msgid="198902765179270739">"2. Select <xliff:g id="CAR_NAME">%1$s</xliff:g> on your phone to pair the devices"</string>
    <string name="trusted_device_safety_alert" msgid="8937542424166378247">"Smart Lock can\'t detect security features of this device. To help protect your car, trusted device will only be able to keep your car unlocked once it\'s already unlocked by you. Your trusted device can keep your car unlocked when it\'s nearby, even if someone else is holding it."</string>
    <string name="trusted_device_pairing_code_dialog_title" msgid="6551880047490332731">"Add <xliff:g id="DEVICE_NAME">%1$s</xliff:g> as a trusted device"</string>
    <string name="trusted_device_success_enrollment_toast" msgid="3275482710090416690">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> successfully added as a trusted device"</string>
    <string name="trusted_device_fail_enrollment_toast" msgid="6801324174861209092">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> enrolment failed"</string>
    <string name="trusted_device_set_authentication_reminder" msgid="5947077589994822305">"Adding a trusted device requires you to set an authentication method next. If you do not have your trusted device with you, authentication will be required to access your profile."</string>
    <string name="forget" msgid="3971143908183848527">"Forget"</string>
    <string name="connect" msgid="5861699594602380150">"Connect"</string>
    <string name="disconnect" msgid="6140789953324820336">"Disconnect"</string>
    <string name="delete_button" msgid="5840500432614610850">"Delete"</string>
    <string name="remove_button" msgid="6664656962868194178">"Remove"</string>
    <string name="cancel" msgid="750286395700355455">"Cancel"</string>
    <string name="backspace_key" msgid="1545590866688979099">"Backspace key"</string>
    <string name="enter_key" msgid="2121394305541579468">"Enter key"</string>
    <string name="exit_retail_button_text" msgid="6093240315583384473">"Exit Demo"</string>
    <string name="exit_retail_mode_dialog_title" msgid="7970631760237469168">"Exit demo mode"</string>
    <string name="exit_retail_mode_dialog_body" msgid="8314316171782527301">"This will delete the demo account and factory data reset the system. All user data will be lost."</string>
    <string name="exit_retail_mode_dialog_confirmation_button_text" msgid="3147249675355968649">"Exit Demo"</string>
    <string name="suggestion_dismiss_button" msgid="4539412646977050641">"DISMISS"</string>
    <string name="restricted_while_driving" msgid="6217369093121968299">"Feature not available while driving."</string>
    <string name="add_user_restricted_while_driving" msgid="6384004350628271556">"Can\'t add user while driving."</string>
</resources>
